5 #ifndef V8_MAGLEV_MAGLEV_IR_H_
6 #define V8_MAGLEV_MAGLEV_IR_H_
52 #ifdef V8_ENABLE_EXPERIMENTAL_UNDEFINED_DOUBLE
53 #define IF_UD(Macro, ...) Macro(__VA_ARGS__)
55 #define IF_UD(Macro, ...)
66 class ProcessingState;
67 class MaglevAssembler;
68 class MaglevCodeGenState;
69 class MaglevCompilationUnit;
70 class MaglevGraphLabeller;
71 class MaglevVregAllocationState;
72 class CompactInterpreterFrameState;
73 class MergePointInterpreterFrameState;
74 class ExceptionHandlerInfo;
83 #define GENERIC_OPERATIONS_NODE_LIST(V) \
89 V(GenericExponentiate) \
90 V(GenericBitwiseAnd) \
92 V(GenericBitwiseXor) \
94 V(GenericShiftRight) \
95 V(GenericShiftRightLogical) \
96 V(GenericBitwiseNot) \
101 V(GenericStrictEqual) \
103 V(GenericLessThanOrEqual) \
104 V(GenericGreaterThan) \
105 V(GenericGreaterThanOrEqual)
107 #define INT32_OPERATIONS_NODE_LIST(V) \
108 V(Int32AbsWithOverflow) \
109 V(Int32AddWithOverflow) \
110 V(Int32SubtractWithOverflow) \
111 V(Int32MultiplyWithOverflow) \
112 V(Int32DivideWithOverflow) \
113 V(Int32ModulusWithOverflow) \
119 V(Int32ShiftRightLogical) \
121 V(Int32NegateWithOverflow) \
122 V(Int32IncrementWithOverflow) \
123 V(Int32DecrementWithOverflow) \
127 #define FLOAT64_OPERATIONS_NODE_LIST(V) \
133 V(Float64Exponentiate) \
138 V(Float64ToBoolean) \
139 V(Float64Ieee754Unary)
141 #define SMI_OPERATIONS_NODE_LIST(V) \
142 V(CheckedSmiIncrement) \
143 V(CheckedSmiDecrement)
145 #define CONSTANT_VALUE_NODE_LIST(V) \
153 V(TaggedIndexConstant) \
156 #define INLINE_BUILTIN_NODE_LIST(V) \
157 V(BuiltinStringFromCharCode) \
158 V(BuiltinStringPrototypeCharCodeOrCodePointAt) \
159 V(BuiltinSeqOneByteStringCharCodeAt)
161 #define TURBOLEV_VALUE_NODE_LIST(V) \
162 V(CreateFastArrayElements) \
164 V(MapPrototypeGetInt32Key) \
167 #define TURBOLEV_NON_VALUE_NODE_LIST(V) V(TransitionAndStoreArrayElement)
169 #define VALUE_NODE_LIST(V) \
172 V(ArgumentsElements) \
178 V(CallForwardVarargs) \
180 V(CallWithArrayLike) \
182 V(CallKnownApiFunction) \
183 V(CallKnownJSFunction) \
186 V(CheckConstructResult) \
187 V(CheckDerivedConstructResult) \
188 V(ConstructWithSpread) \
190 V(ConvertHoleToUndefined) \
191 V(CreateArrayLiteral) \
192 V(CreateShallowArrayLiteral) \
193 V(CreateObjectLiteral) \
194 V(CreateShallowObjectLiteral) \
195 V(CreateFunctionContext) \
197 V(FastCreateClosure) \
198 V(CreateRegExpLiteral) \
200 V(EnsureWritableFastElements) \
201 V(ExtendPropertiesBackingStore) \
202 V(InlinedAllocation) \
205 V(GeneratorRestoreRegister) \
207 V(GetSecondReturnedValue) \
208 V(GetTemplateObject) \
209 V(HasInPrototypeChain) \
212 V(LoadTaggedFieldForProperty) \
213 V(LoadTaggedFieldForContextSlotNoCells) \
214 V(LoadTaggedFieldForContextSlot) \
218 V(LoadTaggedFieldByFieldIndex) \
219 V(LoadFixedArrayElement) \
220 V(LoadFixedDoubleArrayElement) \
221 V(LoadHoleyFixedDoubleArrayElement) \
222 V(LoadHoleyFixedDoubleArrayElementCheckedNotHole) \
223 V(LoadSignedIntDataViewElement) \
224 V(LoadDoubleDataViewElement) \
225 V(LoadTypedArrayLength) \
226 V(LoadSignedIntTypedArrayElement) \
227 V(LoadUnsignedIntTypedArrayElement) \
228 V(LoadDoubleTypedArrayElement) \
229 V(LoadSignedIntConstantTypedArrayElement) \
230 V(LoadUnsignedIntConstantTypedArrayElement) \
231 V(LoadDoubleConstantTypedArrayElement) \
232 V(LoadEnumCacheLength) \
234 V(LoadNamedGeneric) \
235 V(LoadNamedFromSuperGeneric) \
236 V(MaybeGrowFastElements) \
237 V(MigrateMapIfNeeded) \
239 V(DefineNamedOwnGeneric) \
240 V(StoreInArrayLiteralGeneric) \
244 V(DefineKeyedOwnGeneric) \
247 V(CheckedSmiSizedInt32) \
248 V(CheckedSmiTagInt32) \
249 V(CheckedSmiTagUint32) \
250 V(CheckedSmiTagIntPtr) \
251 V(UnsafeSmiTagInt32) \
252 V(UnsafeSmiTagUint32) \
253 V(UnsafeSmiTagIntPtr) \
256 V(CheckedInternalizedString) \
257 V(CheckedObjectToIndex) \
258 V(CheckedTruncateNumberOrOddballToInt32) \
259 V(CheckedInt32ToUint32) \
260 V(CheckedIntPtrToUint32) \
261 V(UnsafeInt32ToUint32) \
262 V(CheckedUint32ToInt32) \
263 V(CheckedIntPtrToInt32) \
264 V(ChangeInt32ToFloat64) \
265 V(ChangeUint32ToFloat64) \
266 V(ChangeIntPtrToFloat64) \
267 V(CheckedTruncateFloat64ToInt32) \
268 V(CheckedTruncateFloat64ToUint32) \
269 V(TruncateNumberOrOddballToInt32) \
270 V(TruncateUint32ToInt32) \
271 V(TruncateFloat64ToInt32) \
272 V(UnsafeTruncateUint32ToInt32) \
273 V(UnsafeTruncateFloat64ToInt32) \
274 V(Int32ToUint8Clamped) \
275 V(Uint32ToUint8Clamped) \
276 V(Float64ToUint8Clamped) \
277 V(CheckedNumberToUint8Clamped) \
280 V(Int32CountLeadingZeros) \
281 V(SmiCountLeadingZeros) \
282 V(Float64CountLeadingZeros) \
286 V(Float64ToHeapNumberForField) \
287 V(HoleyFloat64ToTagged) \
288 V(CheckedSmiTagFloat64) \
289 V(CheckedNumberToInt32) \
290 V(CheckedNumberOrOddballToFloat64) \
291 V(UncheckedNumberOrOddballToFloat64) \
292 V(CheckedNumberOrOddballToHoleyFloat64) \
293 V(CheckedHoleyFloat64ToFloat64) \
294 V(HoleyFloat64ToMaybeNanFloat64) \
295 IF_UD(V, Float64ToHoleyFloat64) \
296 IF_UD(V, ConvertHoleNanToUndefinedNan) \
297 V(HoleyFloat64IsHole) \
299 V(SetPendingMessage) \
304 V(SeqOneByteStringAt) \
306 V(UnwrapStringWrapper) \
308 V(ToBooleanLogicalNot) \
309 V(AllocateElementsArray) \
313 V(TestUndetectable) \
316 V(ToNumberOrNumeric) \
319 V(TransitionElementsKind) \
321 V(UpdateJSArrayLength) \
323 V(GetContinuationPreservedEmbedderData) \
324 CONSTANT_VALUE_NODE_LIST(V) \
325 INT32_OPERATIONS_NODE_LIST(V) \
326 FLOAT64_OPERATIONS_NODE_LIST(V) \
327 SMI_OPERATIONS_NODE_LIST(V) \
328 GENERIC_OPERATIONS_NODE_LIST(V) \
329 INLINE_BUILTIN_NODE_LIST(V) \
330 TURBOLEV_VALUE_NODE_LIST(V)
332 #define GAP_MOVE_NODE_LIST(V) \
336 #define NON_VALUE_NODE_LIST(V) \
338 V(CheckDynamicValue) \
340 V(CheckUint32IsSmi) \
341 V(CheckIntPtrIsSmi) \
342 V(CheckHoleyFloat64IsSmi) \
344 V(CheckInt32Condition) \
345 V(CheckCacheIndicesNotCleared) \
346 V(CheckJSDataViewBounds) \
347 V(CheckTypedArrayBounds) \
348 V(CheckTypedArrayNotDetached) \
350 V(CheckMapsWithMigrationAndDeopt) \
351 V(CheckMapsWithMigration) \
352 V(CheckMapsWithAlreadyLoadedMap) \
353 V(CheckDetectableCallable) \
354 V(CheckJSReceiverOrNullOrUndefined) \
356 V(CheckHoleyFloat64NotHole) \
360 V(CheckSeqOneByteString) \
361 V(CheckStringOrStringWrapper) \
362 V(CheckStringOrOddball) \
365 V(CheckValueEqualsInt32) \
366 V(CheckFloat64SameValue) \
367 V(CheckValueEqualsString) \
368 V(CheckInstanceType) \
371 V(FunctionEntryStackCheck) \
373 V(TryOnStackReplacement) \
375 V(StoreDoubleField) \
376 V(StoreFixedArrayElementWithWriteBarrier) \
377 V(StoreFixedArrayElementNoWriteBarrier) \
378 V(StoreFixedDoubleArrayElement) \
381 V(StoreIntTypedArrayElement) \
382 V(StoreDoubleTypedArrayElement) \
383 V(StoreIntConstantTypedArrayElement) \
384 V(StoreDoubleConstantTypedArrayElement) \
385 V(StoreSignedIntDataViewElement) \
386 V(StoreDoubleDataViewElement) \
387 V(StoreTaggedFieldNoWriteBarrier) \
388 V(StoreTaggedFieldWithWriteBarrier) \
389 V(StoreContextSlotWithWriteBarrier) \
390 V(StoreTrustedPointerFieldWithWriteBarrier) \
391 V(HandleNoHeapWritesInterrupt) \
392 V(ReduceInterruptBudgetForLoop) \
393 V(ReduceInterruptBudgetForReturn) \
394 V(ThrowReferenceErrorIfHole) \
395 V(ThrowSuperNotCalledIfHole) \
396 V(ThrowSuperAlreadyCalledIfNotHole) \
397 V(ThrowIfNotCallable) \
398 V(ThrowIfNotSuperConstructor) \
399 V(TransitionElementsKindOrCheckMap) \
400 V(SetContinuationPreservedEmbedderData) \
401 GAP_MOVE_NODE_LIST(V) \
402 TURBOLEV_NON_VALUE_NODE_LIST(V)
404 #define NODE_LIST(V) \
405 NON_VALUE_NODE_LIST(V) \
408 #define BRANCH_CONTROL_NODE_LIST(V) \
410 V(BranchIfRootConstant) \
411 V(BranchIfToBooleanTrue) \
412 V(BranchIfInt32ToBooleanTrue) \
413 V(BranchIfIntPtrToBooleanTrue) \
414 V(BranchIfFloat64ToBooleanTrue) \
415 V(BranchIfFloat64IsHole) \
416 IF_UD(V, BranchIfFloat64IsUndefinedOrHole) \
417 V(BranchIfReferenceEqual) \
418 V(BranchIfInt32Compare) \
419 V(BranchIfUint32Compare) \
420 V(BranchIfFloat64Compare) \
421 V(BranchIfUndefinedOrNull) \
422 V(BranchIfUndetectable) \
423 V(BranchIfJSReceiver) \
426 #define CONDITIONAL_CONTROL_NODE_LIST(V) \
428 BRANCH_CONTROL_NODE_LIST(V)
430 #define UNCONDITIONAL_CONTROL_NODE_LIST(V) \
432 V(CheckpointedJump) \
435 #define TERMINAL_CONTROL_NODE_LIST(V) \
440 #define CONTROL_NODE_LIST(V) \
441 TERMINAL_CONTROL_NODE_LIST(V) \
442 CONDITIONAL_CONTROL_NODE_LIST(V) \
443 UNCONDITIONAL_CONTROL_NODE_LIST(V)
445 #define NODE_BASE_LIST(V) \
450 #define DEF_OPCODES(type) k##type,
453 #define PLUS_ONE(type) +1
464 #define V(Name) Opcode::k##Name,
516 case Opcode::kFloat64Add:
517 case Opcode::kFloat64Multiply:
518 case Opcode::kGenericStrictEqual:
519 case Opcode::kInt32AddWithOverflow:
520 case Opcode::kInt32BitwiseAnd:
521 case Opcode::kInt32BitwiseOr:
522 case Opcode::kInt32BitwiseXor:
523 case Opcode::kInt32MultiplyWithOverflow:
524 case Opcode::kStringEqual:
525 case Opcode::kTaggedEqual:
526 case Opcode::kTaggedNotEqual:
534 case Opcode::kTruncateUint32ToInt32:
535 case Opcode::kUnsafeTruncateUint32ToInt32:
536 case Opcode::kIdentity:
567 return opcode == Opcode::kStoreTaggedFieldWithWriteBarrier ||
568 opcode == Opcode::kStoreTaggedFieldNoWriteBarrier ||
569 opcode == Opcode::kStoreDoubleField ||
570 opcode == Opcode::kStoreFloat64 || opcode == Opcode::kStoreInt32 ||
571 opcode == Opcode::kUpdateJSArrayLength ||
572 opcode == Opcode::kStoreFixedArrayElementWithWriteBarrier ||
573 opcode == Opcode::kStoreFixedArrayElementNoWriteBarrier ||
574 opcode == Opcode::kStoreFixedDoubleArrayElement ||
575 opcode == Opcode::kStoreTrustedPointerFieldWithWriteBarrier;
578 return opcode == Opcode::kMaybeGrowFastElements ||
579 opcode == Opcode::kEnsureWritableFastElements;
582 return opcode == Opcode::kStoreIntTypedArrayElement ||
583 opcode == Opcode::kStoreDoubleTypedArrayElement;
588 case Opcode::kStoreMap:
589 case Opcode::kStoreInt32:
590 case Opcode::kStoreTrustedPointerFieldWithWriteBarrier:
591 case Opcode::kStoreTaggedFieldWithWriteBarrier:
592 case Opcode::kStoreTaggedFieldNoWriteBarrier:
593 case Opcode::kStoreContextSlotWithWriteBarrier:
594 case Opcode::kStoreFloat64:
604 class ConditionalControlNode;
605 class BranchControlNode;
606 class UnconditionalControlNode;
607 class TerminalControlNode;
625 #if defined(V8_TARGET_ARCH_RISCV64)
637 #define LEAF_NODE_TYPE_LIST(V) \
639 V(HeapNumber, (1 << 1)) \
641 V(Undefined, (1 << 3)) \
642 V(Boolean, (1 << 4)) \
643 V(Symbol, (1 << 5)) \
660 V(ROSeqInternalizedOneByteString, (1 << 6)) \
661 V(OtherSeqInternalizedOneByteString, (1 << 7)) \
662 V(OtherInternalizedString, (1 << 8)) \
663 V(OtherSeqOneByteString, (1 << 9)) \
664 V(OtherString, (1 << 10)) \
666 V(Context, (1 << 11)) \
667 V(StringWrapper, (1 << 12)) \
668 V(JSArray, (1 << 13)) \
669 V(JSFunction, (1 << 14)) \
670 V(OtherCallable, (1 << 15)) \
671 V(OtherHeapObject, (1 << 16)) \
672 V(OtherJSReceiver, (1 << 17))
674 #define COUNT(...) +1
678 #define COMBINED_NODE_TYPE_LIST(V) \
680 V(Unknown, ((1 << kNumberOfLeafNodeTypes) - 1)) \
681 V(Callable, kJSFunction | kOtherCallable) \
682 V(NullOrUndefined, kNull | kUndefined) \
683 V(Oddball, kNullOrUndefined | kBoolean) \
684 V(Number, kSmi | kHeapNumber) \
685 V(NumberOrBoolean, kNumber | kBoolean) \
686 V(NumberOrOddball, kNumber | kOddball) \
687 V(InternalizedString, kROSeqInternalizedOneByteString | \
688 kOtherSeqInternalizedOneByteString | \
689 kOtherInternalizedString) \
690 V(SeqOneByteString, kROSeqInternalizedOneByteString | \
691 kOtherSeqInternalizedOneByteString | \
692 kOtherSeqOneByteString) \
693 V(String, kInternalizedString | kSeqOneByteString | kOtherString) \
694 V(StringOrStringWrapper, kString | kStringWrapper) \
695 V(StringOrOddball, kString | kOddball) \
696 V(Name, kString | kSymbol) \
697 V(JSReceiver, kJSArray | kCallable | kStringWrapper | kOtherJSReceiver) \
698 V(JSReceiverOrNullOrUndefined, kJSReceiver | kNullOrUndefined) \
699 V(AnyHeapObject, kUnknown - kSmi)
701 #define NODE_TYPE_LIST(V) \
702 LEAF_NODE_TYPE_LIST(V) \
703 COMBINED_NODE_TYPE_LIST(V)
706 #define DEFINE_NODE_TYPE(Name, Value) k##Name = Value,
708 #undef DEFINE_NODE_TYPE
718 case NodeType::kOtherCallable:
719 case NodeType::kOtherInternalizedString:
720 case NodeType::kOtherSeqInternalizedOneByteString:
721 case NodeType::kOtherSeqOneByteString:
722 case NodeType::kOtherString:
764 if (string_type == NodeType::kROSeqInternalizedOneByteString)
return false;
767 if (string_type == NodeType::kInternalizedString)
return false;
769 if (string_type == NodeType::kString)
return false;
792 NodeType::kSeqOneByteString)));
795 NodeType::kInternalizedString)));
809 if (
NodeTypeIs(string_type, NodeType::kInternalizedString)) {
822 static_assert(
MakeTypeStable(NodeType::kSeqOneByteString) == NodeType::kString);
825 NodeType::kInternalizedString);
827 static_assert(
MakeTypeStable(NodeType::kROSeqInternalizedOneByteString) ==
828 NodeType::kROSeqInternalizedOneByteString);
832 NodeType::kSeqOneByteString)) ==
833 UnionType(NodeType::kNumber, NodeType::kString));
836 #define ADD_STATIC_ASSERT(Name, Value) \
837 static_assert(NodeTypeIsNeverStandalone(NodeType::k##Name) || \
838 NodeTypeIs(NodeType::k##Name, NodeType::kUnknown));
840 #undef ADD_STATIC_ASSERT
844 if (map.IsHeapNumberMap())
return NodeType::kHeapNumber;
845 if (map.IsStringMap()) {
846 if (map.IsInternalizedStringMap()) {
847 return NodeType::kInternalizedString;
850 return NodeType::kSeqOneByteString;
852 return NodeType::kString;
855 if (map.IsSymbolMap())
return NodeType::kSymbol;
857 if (map.IsOddballMap()) {
859 return NodeType::kNullOrUndefined;
861 if (map.IsContextMap())
return NodeType::kContext;
862 if (map.IsJSArrayMap())
return NodeType::kJSArray;
863 if (map.IsJSFunctionMap())
return NodeType::kJSFunction;
865 return NodeType::kCallable;
867 if (map.IsJSReceiverMap()) {
869 return NodeType::kOtherJSReceiver;
871 return NodeType::kOtherHeapObject;
876 return static_cast<int>(
type) == 0;
880 compiler::ObjectRef ref) {
884 if (
type == NodeType::kInternalizedString && ref.is_read_only()) {
885 if (ref.AsString().IsSeqString() &&
886 ref.AsString().IsOneByteRepresentation()) {
887 type = NodeType::kROSeqInternalizedOneByteString;
898 case NodeType::kHeapNumber:
899 return map.IsHeapNumberMap();
900 case NodeType::kNull:
902 case NodeType::kUndefined:
904 case NodeType::kBoolean:
906 case NodeType::kSymbol:
907 return map.IsSymbolMap();
908 case NodeType::kOtherString:
911 return map.IsStringMap();
912 case NodeType::kOtherSeqOneByteString:
916 case NodeType::kROSeqInternalizedOneByteString:
917 case NodeType::kOtherSeqInternalizedOneByteString:
920 case NodeType::kOtherInternalizedString:
921 return map.IsInternalizedStringMap();
922 case NodeType::kStringWrapper:
924 case NodeType::kContext:
925 return map.IsContextMap();
926 case NodeType::kJSArray:
927 return map.IsJSArrayMap();
928 case NodeType::kJSFunction:
929 return map.IsJSFunctionMap();
930 case NodeType::kCallable:
932 case NodeType::kOtherCallable:
933 return map.
is_callable() && !map.IsJSFunctionMap();
934 case NodeType::kOtherJSReceiver:
935 return map.IsJSReceiverMap() && !map.IsJSArrayMap() &&
937 case NodeType::kOtherHeapObject:
938 return !map.IsHeapNumberMap() && !map.IsOddballMap() &&
939 !map.IsContextMap() && !map.IsSymbolMap() && !map.IsStringMap() &&
940 !map.IsJSReceiverMap();
953 static_assert(
NodeTypeIs(NodeType::kAnyHeapObject, NodeType::kUnknown));
960 while (type_bits != 0) {
976 #define CASE(Name, _) \
977 case NodeType::k##Name: \
983 #define CASE(Name, _) \
984 if (NodeTypeIs(NodeType::k##Name, type)) { \
985 if constexpr (NodeType::k##Name != NodeType::kUnknown) { \
995 #define DEFINE_NODE_TYPE_CHECK(Type, _) \
996 inline bool NodeTypeIs##Type(NodeType type) { \
997 return NodeTypeIs(type, NodeType::k##Type); \
1000 #undef DEFINE_NODE_TYPE_CHECK
1003 return (
static_cast<int>(
type) &
1004 static_cast<int>(NodeType::kNullOrUndefined)) != 0;
1023 return os <<
"Tagged";
1025 return os <<
"Int32";
1027 return os <<
"Uint32";
1029 return os <<
"Float64";
1031 return os <<
"HoleyFloat64";
1033 return os <<
"Word64";
1039 switch (conversion_type) {
1041 return os <<
"Number";
1043 return os <<
"NumberOrBoolean";
1045 return os <<
"NumberOrOddball";
1051 if (!map.IsJSTypedArrayMap())
return false;
1058 if (!map.IsJSArrayMap())
return false;
1065 if (!map.IsJSObjectMap())
return false;
1072 if (!map.IsStringMap())
return false;
1079 if (map.instance_type() != HEAP_NUMBER_TYPE)
return false;
1086 if (map.instance_type() == HEAP_NUMBER_TYPE)
return true;
1091 #define DEF_FORWARD_DECLARATION(type, ...) class type;
1093 #undef DEF_FORWARD_DECLARATION
1103 struct BasicBlockRefBuilder;
1113 state_ = kBlockPointer;
1140 state_ = kBlockPointer;
1142 return old_next_ptr;
1152 return old_next_ptr;
1159 DCHECK_EQ(ref_list_head->state_, kRefList);
1164 return old_next_ptr;
1203 enum { kBlockPointer, kRefList } state_;
1435 template <
typename... Args>
1441 template <
typename... Args>
1455 return compiler::UnallocatedOperand::cast(
operand_).IsUsedAtStart();
1458 template <
typename... Args>
1614 int result_size)
const;
1624 static_assert(
sizeof(InterpretedDeoptFrame) ==
sizeof(DeoptFrame));
1662 static_assert(
sizeof(InlinedArgumentsDeoptFrame) ==
sizeof(DeoptFrame));
1701 static_assert(
sizeof(ConstructInvokeStubDeoptFrame) ==
sizeof(DeoptFrame));
1719 compiler::OptionalJSFunctionRef maybe_js_target,
1744 static_assert(
sizeof(BuiltinContinuationDeoptFrame) ==
sizeof(DeoptFrame));
1746 inline const BuiltinContinuationDeoptFrame&
1847 size_t input_location_count() {
return input_location_count_; }
1855 size_t input_location_count_ = 0;
1876 template <
typename Function>
1878 template <
typename Function>
1897 DCHECK(IsConsideredForResultLocation());
1901 DCHECK(IsConsideredForResultLocation());
1907 DCHECK(IsConsideredForResultLocation());
1929 template <
typename Function>
1931 template <
typename Function>
1936 bool IsConsideredForResultLocation()
const {
1948 switch (
top_frame().as_builtin_continuation().builtin_id()) {
1949 case Builtin::kGenericLazyDeoptContinuation:
1950 case Builtin::kGetIteratorWithFeedbackLazyDeoptContinuation:
1951 case Builtin::kCallIteratorWithFeedbackLazyDeoptContinuation:
2046 #define DEF_OPCODE_OF(Name) \
2048 struct opcode_of_helper<Name> { \
2049 static constexpr Opcode value = Opcode::k##Name; \
2052 #undef DEF_OPCODE_OF
2054 template <
typename T>
2056 char* address_as_char_ptr =
reinterpret_cast<char*
>(address);
2057 char* object_ptr_as_char_ptr = address_as_char_ptr -
sizeof(
T);
2058 return reinterpret_cast<T*
>(object_ptr_as_char_ptr);
2061 template <
typename T>
2063 const char* address_as_char_ptr =
reinterpret_cast<const char*
>(address);
2064 const char* object_ptr_as_char_ptr = address_as_char_ptr -
sizeof(
T);
2065 return reinterpret_cast<const T*
>(object_ptr_as_char_ptr);
2070 #define DEOPTIMIZE_REASON_FIELD \
2072 using ReasonField = \
2073 NextBitField<DeoptimizeReason, base::bits::WhichPowerOfTwo<size_t>( \
2074 base::bits::RoundUpToPowerOfTwo32( \
2075 kDeoptimizeReasonCount))>; \
2078 DeoptimizeReason deoptimize_reason() const { \
2079 return ReasonField::decode(bitfield()); \
2082 struct KnownNodeAspects;
2100 template <
class T,
int size>
2109 template <
class Derived,
typename... Args>
2110 static Derived*
New(
Zone* zone, std::initializer_list<ValueNode*> inputs,
2112 static_assert(Derived::kProperties.is_conversion(),
2113 "This method does not implicitly convert input types. Use "
2114 "MaglevGraphBuilder::AddNewNode instead or NodeBase::New and "
2115 "initialize and convert inputs manually.");
2117 Allocate<Derived>(zone, inputs.size(), std::forward<Args>(
args)...);
2122 node->set_input(
i++,
input);
2129 template <
class Derived,
typename... Args>
2151 constexpr
bool Is()
const;
2156 return static_cast<T*
>(
this);
2161 return static_cast<const T*
>(
this);
2165 return Is<T>() ?
static_cast<T*
>(
this) :
nullptr;
2170 return Is<T>() ?
static_cast<const T*
>(
this) :
nullptr;
2193 constexpr
auto begin() {
return std::make_reverse_iterator(&
input(-1)); }
2209 template <
typename RegisterT>
2211 if constexpr (std::is_same_v<RegisterT, Register>) {
2218 template <
typename RegisterT>
2225 template <
typename RegisterT>
2237 template <
typename Function>
2241 bool skip_targets =
false)
const;
2302 template <
typename NodeT>
2304 OverwriteWith(NodeBase::opcode_of<NodeT>, NodeT::kProperties);
2309 std::optional<OpProperties> maybe_new_properties = std::nullopt) {
2310 OpProperties new_properties = maybe_new_properties.has_value()
2311 ? maybe_new_properties.value()
2342 const uint64_t base_bitfield_mask =
2346 new_bitfield & base_bitfield_mask);
2352 return detail::ObjectPtrBeforeAddress<Input>(
this);
2355 return detail::ObjectPtrBeforeAddress<Input>(
this);
2382 DCHECK_EQ(num_temporaries_needed<Register>(), 0);
2387 DCHECK_EQ(num_temporaries_needed<DoubleRegister>(), 0);
2402 template <
class Derived,
typename... Args>
2405 !Derived::kProperties.can_eager_deopt() ||
2406 !Derived::kProperties.can_lazy_deopt(),
2407 "The current deopt info representation, at the end of inputs, requires "
2408 "that we cannot have both lazy and eager deopts on a node. If we ever "
2409 "need this, we have to update accessors to check node->properties() "
2410 "for which deopts are active.");
2411 constexpr
size_t size_before_inputs =
2418 const size_t size_before_node =
2422 const size_t size = size_before_node +
sizeof(Derived);
2423 intptr_t raw_buffer =
2426 memset(
reinterpret_cast<void*
>(raw_buffer), 0,
size);
2429 void* node_buffer =
reinterpret_cast<void*
>(raw_buffer + size_before_node);
2434 new (node_buffer) Derived(
bitfield, std::forward<Args>(
args)...);
2439 return RoundUp<alignof(Input)>(
2444 return RoundUp<alignof(Input)>(
2449 return RoundUp<alignof(Input)>(
2456 return RoundUp<alignof(Input)>(
2494 template <
typename RegisterT>
2497 if constexpr (std::is_same_v<RegisterT, Register>) {
2506 DCHECK(state_ == State::kNull || state_ == State::kOwner);
2507 state_ = State::kOwner;
2514 DCHECK(state_ == State::kNull || state_ == State::kOwner);
2515 state_ = State::kReglist;
2538 State state_ = State::kNull;
2553 return opcode() == opcode_of<T>;
2558 constexpr
bool NodeBase::Is<ValueNode>()
const {
2562 constexpr
bool NodeBase::Is<ControlNode>()
const {
2566 constexpr
bool NodeBase::Is<BranchControlNode>()
const {
2570 constexpr
bool NodeBase::Is<ConditionalControlNode>()
const {
2574 constexpr
bool NodeBase::Is<UnconditionalControlNode>()
const {
2578 constexpr
bool NodeBase::Is<TerminalControlNode>()
const {
2596 op != Opcode::kCheckMaps;
2645 template <
typename RegisterT>
2648 return RegisterT::from_code(
2649 compiler::UnallocatedOperand::cast(
hint_).fixed_register_index());
2679 if (state_ == kLastUse) {
2737 #ifdef V8_COMPRESS_POINTERS
2742 void SetTaggedResultNeedsDecompress() {
2749 for (Input&
input : *
this) {
2752 input.
node()->SetTaggedResultNeedsDecompress();
2754 }
else if (Is<Identity>()) {
2756 input(0).
node()->SetTaggedResultNeedsDecompress();
2818 template <
typename T>
2842 template <
typename T>
2844 if constexpr (std::is_same_v<T, DoubleRegister>) {
2867 hint_(compiler::InstructionOperand()),
2905 enum {kLastUse, kSpill} state_;
2936 return Cast<ValueNode>()->result();
2941 template <
typename Base,
typename Derived>
2947 return Derived::kProperties;
2950 template <
typename... Args>
2951 static Derived*
New(
Zone* zone, std::initializer_list<ValueNode*> inputs,
2953 return NodeBase::New<Derived>(zone, inputs, std::forward<Args>...);
2955 template <
typename... Args>
2957 return NodeBase::New<Derived>(zone,
input_count, std::forward<Args>...);
2961 template <
typename... Args>
2963 : Base(bitfield, std::forward<Args>(
args)...) {
2972 template <
size_t Size>
2975 template <
typename... Args>
2978 static_assert(
sizeof...(
args) == Size);
2986 template <
size_t InputCount,
typename Base,
typename Derived>
2995 return std::make_reverse_iterator(&this->input(
input_count() - 1));
3001 std::is_same_v<
const InputTypes, decltype(Derived::kInputTypes)>);
3009 #ifdef V8_COMPRESS_POINTERS
3010 void MarkTaggedInputsAsDecompressing()
const {
3013 std::is_same_v<
const InputTypes, decltype(Derived::kInputTypes)>);
3017 ValueNode* input_node = this->input(
i).node();
3018 input_node->SetTaggedResultNeedsDecompress();
3029 template <
typename... Args>
3031 :
NodeTMixin<Base, Derived>(bitfield, std::forward<Args>(
args)...) {
3036 template <
class T,
class =
void>
3040 :
public std::true_type {};
3042 template <
class Derived>
3045 template <
class Derived>
3048 template <
size_t InputCount,
class Derived>
3052 template <
size_t InputCount,
class Derived>
3067 #ifdef V8_COMPRESS_POINTERS
3068 void MarkTaggedInputsAsDecompressing() {
3079 template <
class Derived, Operation kOperation>
3105 template <
class Derived, Operation kOperation>
3133 #define DEF_OPERATION_WITH_FEEDBACK_NODE(Name, Super, OpName) \
3134 class Name : public Super<Name, Operation::k##OpName> { \
3135 using Base = Super<Name, Operation::k##OpName>; \
3138 Name(uint64_t bitfield, const compiler::FeedbackSource& feedback) \
3139 : Base(bitfield, feedback) {} \
3140 int MaxCallStackArgs() const { return 0; } \
3141 void SetValueLocationConstraints(); \
3142 void GenerateCode(MaglevAssembler*, const ProcessingState&); \
3143 void PrintParams(std::ostream&, MaglevGraphLabeller*) const {} \
3146 #define DEF_UNARY_WITH_FEEDBACK_NODE(Name) \
3147 DEF_OPERATION_WITH_FEEDBACK_NODE(Generic##Name, UnaryWithFeedbackNode, Name)
3148 #define DEF_BINARY_WITH_FEEDBACK_NODE(Name) \
3149 DEF_OPERATION_WITH_FEEDBACK_NODE(Generic##Name, BinaryWithFeedbackNode, Name)
3153 #undef DEF_UNARY_WITH_FEEDBACK_NODE
3154 #undef DEF_BINARY_WITH_FEEDBACK_NODE
3155 #undef DEF_OPERATION_WITH_FEEDBACK_NODE
3157 template <
class Derived, Operation kOperation>
3178 #define DEF_OPERATION_NODE(Name, Super, OpName) \
3179 class Name : public Super<Name, Operation::k##OpName> { \
3180 using Base = Super<Name, Operation::k##OpName>; \
3183 explicit Name(uint64_t bitfield) : Base(bitfield) {} \
3184 void SetValueLocationConstraints(); \
3185 void GenerateCode(MaglevAssembler*, const ProcessingState&); \
3186 void PrintParams(std::ostream&, MaglevGraphLabeller*) const {} \
3189 #define DEF_INT32_BINARY_WITH_OVERFLOW_NODE(Name) \
3190 DEF_OPERATION_NODE(Int32##Name##WithOverflow, Int32BinaryWithOverflowNode, \
3197 #undef DEF_INT32_BINARY_WITH_OVERFLOW_NODE
3199 template <
class Derived, Operation kOperation>
3217 #define DEF_INT32_BINARY_NODE(Name) \
3218 DEF_OPERATION_NODE(Int32##Name, Int32BinaryNode, Name)
3224 #undef DEF_INT32_BINARY_NODE
3244 template <
class Derived, Operation kOperation>
3261 #define DEF_INT32_UNARY_WITH_OVERFLOW_NODE(Name) \
3262 DEF_OPERATION_NODE(Int32##Name##WithOverflow, Int32UnaryWithOverflowNode, \
3268 #undef DEF_INT32_UNARY_WITH_OVERFLOW_NODE
3308 return OperationBitField::decode(bitfield());
3332 constexpr
bool flip()
const {
return FlipBitField::decode(bitfield()); }
3355 constexpr
bool flip()
const {
return FlipBitField::decode(bitfield()); }
3405 template <
class Derived, Operation kOperation>
3425 #define DEF_OPERATION_NODE_WITH_CALL(Name, Super, OpName) \
3426 class Name : public Super<Name, Operation::k##OpName> { \
3427 using Base = Super<Name, Operation::k##OpName>; \
3430 explicit Name(uint64_t bitfield) : Base(bitfield) {} \
3431 int MaxCallStackArgs() const; \
3432 void SetValueLocationConstraints(); \
3433 void GenerateCode(MaglevAssembler*, const ProcessingState&); \
3434 void PrintParams(std::ostream&, MaglevGraphLabeller*) const {} \
3437 template <
class Derived, Operation kOperation>
3458 #define DEF_FLOAT64_BINARY_NODE(Name) \
3459 DEF_OPERATION_NODE(Float64##Name, Float64BinaryNode, Name)
3460 #define DEF_FLOAT64_BINARY_NODE_WITH_CALL(Name) \
3461 DEF_OPERATION_NODE_WITH_CALL(Float64##Name, Float64BinaryNodeWithCall, Name)
3466 #if defined(V8_TARGET_ARCH_ARM64) || defined(V8_TARGET_ARCH_ARM) || \
3467 defined(V8_TARGET_ARCH_RISCV64)
3475 #undef DEF_FLOAT64_BINARY_NODE
3476 #undef DEF_FLOAT64_BINARY_NODE_WITH_CALL
3478 #undef DEF_OPERATION_NODE
3479 #undef DEF_OPERATION_NODE_WITH_CALL
3497 return OperationBitField::decode(bitfield());
3522 constexpr
bool flip()
const {
return FlipBitField::decode(bitfield()); }
3551 #define IEEE_754_UNARY_LIST(V) \
3552 V(MathAcos, acos, Acos) \
3553 V(MathAcosh, acosh, Acosh) \
3554 V(MathAsin, asin, Asin) \
3555 V(MathAsinh, asinh, Asinh) \
3556 V(MathAtan, atan, Atan) \
3557 V(MathAtanh, atanh, Atanh) \
3558 V(MathCbrt, cbrt, Cbrt) \
3559 V(MathCos, cos, Cos) \
3560 V(MathCosh, cosh, Cosh) \
3561 V(MathExp, exp, Exp) \
3562 V(MathExpm1, expm1, Expm1) \
3563 V(MathLog, log, Log) \
3564 V(MathLog1p, log1p, Log1p) \
3565 V(MathLog10, log10, Log10) \
3566 V(MathLog2, log2, Log2) \
3567 V(MathSin, sin, Sin) \
3568 V(MathSinh, sinh, Sinh) \
3569 V(MathTan, tan, Tan) \
3570 V(MathTanh, tanh, Tanh)
3577 #define DECL_ENUM(MathName, ExtName, EnumName) k##EnumName,
3767 #ifdef V8_COMPRESS_POINTERS
3768 void MarkTaggedInputsAsDecompressing() {
3791 #ifdef V8_COMPRESS_POINTERS
3792 void MarkTaggedInputsAsDecompressing() {
3815 #ifdef V8_COMPRESS_POINTERS
3816 void MarkTaggedInputsAsDecompressing() {
3840 #ifdef V8_COMPRESS_POINTERS
3841 void MarkTaggedInputsAsDecompressing() {
3864 #ifdef V8_COMPRESS_POINTERS
3865 void MarkTaggedInputsAsDecompressing() {
4141 return ConversionModeBitField::decode(bitfield());
4146 return ConversionModeBitField::decode(bitfield()) ==
4199 set_bitfield(ConversionModeBitField::update(bitfield(),
mode));
4205 return ConversionModeBitField::decode(bitfield());
4210 return ConversionModeBitField::decode(bitfield()) ==
4515 return Builtin::kMathCeilContinuation;
4517 return Builtin::kMathFloorContinuation;
4519 return Builtin::kMathRoundContinuation;
4562 #define DEFINE_TRUNCATE_NODE(name, from_repr, properties) \
4563 class name : public FixedInputValueNodeT<1, name> { \
4564 using Base = FixedInputValueNodeT<1, name>; \
4567 explicit name(uint64_t bitfield) : Base(bitfield) {} \
4569 static constexpr OpProperties kProperties = properties; \
4570 static constexpr typename Base::InputTypes kInputTypes{ \
4571 ValueRepresentation::k##from_repr}; \
4573 Input& input() { return Node::input(0); } \
4575 void SetValueLocationConstraints(); \
4576 void GenerateCode(MaglevAssembler*, const ProcessingState&); \
4577 void PrintParams(std::ostream&, MaglevGraphLabeller*) const {} \
4587 #undef DEFINE_TRUNCATE_NODE
4589 template <
typename Derived, ValueRepresentation FloatType>
4600 : Base(TaggedToFloat64ConversionTypeOffset::update(bitfield,
4601 conversion_type)) {}
4613 return TaggedToFloat64ConversionTypeOffset::decode(Base::bitfield());
4618 ? DeoptimizeReason::kNotANumberOrBoolean
4619 : DeoptimizeReason::kNotANumberOrOddball;
4622 void SetValueLocationConstraints();
4626 auto options()
const {
return std::tuple{conversion_type()}; }
4629 using TaggedToFloat64ConversionTypeOffset =
4630 Base::template NextBitField<TaggedToFloat64ConversionType, 2>;
4635 CheckedNumberOrOddballToFloat64, ValueRepresentation::kFloat64> {
4642 :
Base(bitfield, conversion_type) {}
4662 return DeoptimizeReason::kNotANumberOrOddball;
4712 return TaggedToFloat64ConversionTypeOffset::decode(bitfield());
4719 NextBitField<TaggedToFloat64ConversionType, 2>;
4762 #ifdef V8_ENABLE_EXPERIMENTAL_UNDEFINED_DOUBLE
4763 class Float64ToHoleyFloat64
4765 using Base = FixedInputValueNodeT<1, Float64ToHoleyFloat64>;
4768 explicit Float64ToHoleyFloat64(uint64_t bitfield) : Base(bitfield) {}
4770 static constexpr OpProperties kProperties =
4777 void SetValueLocationConstraints();
4778 void GenerateCode(MaglevAssembler*,
const ProcessingState&);
4779 void PrintParams(std::ostream&, MaglevGraphLabeller*)
const {}
4782 class ConvertHoleNanToUndefinedNan
4784 using Base = FixedInputValueNodeT<1, ConvertHoleNanToUndefinedNan>;
4787 explicit ConvertHoleNanToUndefinedNan(uint64_t bitfield) : Base(bitfield) {}
4795 int MaxCallStackArgs()
const {
return 0; }
4796 void SetValueLocationConstraints();
4797 void GenerateCode(MaglevAssembler*,
const ProcessingState&);
4798 void PrintParams(std::ostream&, MaglevGraphLabeller*)
const {}
4839 return TaggedToFloat64ConversionTypeOffset::decode(bitfield());
4846 NextBitField<TaggedToFloat64ConversionType, 2>;
4871 return TaggedToFloat64ConversionTypeOffset::decode(bitfield());
4878 NextBitField<TaggedToFloat64ConversionType, 2>;
5007 #ifdef V8_COMPRESS_POINTERS
5008 void MarkTaggedInputsAsDecompressing() {
5030 #ifdef V8_COMPRESS_POINTERS
5031 void MarkTaggedInputsAsDecompressing() {
5230 #ifdef V8_COMPRESS_POINTERS
5231 void MarkTaggedInputsAsDecompressing() {
5430 return ConversionModeBitField::decode(bitfield());
5833 out <<
"ConsString";
5968 int last_init_index = last_init_slot /
kTaggedSize;
5984 if (
map() != other->
map())
return false;
5986 switch (other->
type_) {
6003 template <
typename Function>
6023 template <
typename Function>
6045 template <
typename Function>
6048 template <
typename Function>
6052 template <
typename Function>
6054 uint32_t new_object_id,
Zone* zone,
6068 result->set_by_index(
i, *success);
6080 bool empty_clone =
false)
const {
6089 result = NodeBase::New<VirtualObject>(zone, 0,
map(), new_object_id,
6094 if (empty_clone)
return result;
6191 object->next_ =
head_;
6208 void Print(std::ostream& os,
const char* prefix,
6212 template <
typename Function>
6218 while (vo1 !=
nullptr && vo2 !=
nullptr && vo1 != vo2) {
6220 if (vo1->
id() > vo2->
id()) {
6228 if (vo1 == vo2)
return vo1;
6344 void set_is_returned_value_from_inline_call() {
6345 is_returned_value_from_inline_call_ =
true;
6348 bool is_returned_value_from_inline_call()
const {
6349 return is_returned_value_from_inline_call_;
6360 bool is_returned_value_from_inline_call_ =
false;
6370 template <
typename Function>
6375 value = value->input(0).node();
6382 switch (
value->opcode()) {
6383 case Opcode::kArgumentsElements:
6384 case Opcode::kArgumentsLength:
6385 case Opcode::kRestLength:
6388 case Opcode::kVirtualObject:
6390 case Opcode::kInlinedAllocation: {
6391 InlinedAllocation* alloc = value->Cast<InlinedAllocation>();
6392 VirtualObject* inner_vobject = virtual_objects.FindAllocatedWith(alloc);
6394 if (inner_vobject &&
6395 (!alloc->HasBeenAnalysed() || alloc->HasBeenElided())) {
6396 inner_vobject->ForEachNestedRuntimeInput(virtual_objects, f);
6409 template <
typename Function>
6410 inline void VirtualObject::ForEachNestedRuntimeInput(
6414 value = value->input(0).node();
6421 switch (
value->opcode()) {
6422 case Opcode::kArgumentsElements:
6423 case Opcode::kArgumentsLength:
6424 case Opcode::kRestLength:
6427 case Opcode::kVirtualObject:
6429 case Opcode::kInlinedAllocation: {
6430 InlinedAllocation* alloc = value->Cast<InlinedAllocation>();
6431 VirtualObject* inner_vobject = virtual_objects.FindAllocatedWith(alloc);
6433 if (inner_vobject &&
6434 (!alloc->HasBeenAnalysed() || alloc->HasBeenElided())) {
6435 inner_vobject->ForEachNestedRuntimeInput(virtual_objects, f);
6453 :
Base(bitfield), allocation_type_(allocation_type) {}
6456 OpProperties::DeferredCall() |
6457 OpProperties::NotIdempotent();
6471 allocation_list_.Add(alloc);
6472 size_ += alloc->
size();
6478 return elided_write_barriers_depend_on_type_;
6481 elided_write_barriers_depend_on_type_ =
true;
6485 void TryPretenure();
6488 bool elided_write_barriers_depend_on_type_ =
false;
6500 void SetValueLocationConstraints();
6509 explicit RestLength(uint64_t bitfield,
int formal_parameter_count)
6510 :
Base(bitfield), formal_parameter_count_(formal_parameter_count) {}
6512 void SetValueLocationConstraints();
6518 auto options()
const {
return std::tuple{formal_parameter_count_}; }
6529 int formal_parameter_count)
6532 formal_parameter_count_(formal_parameter_count) {}
6536 OpProperties::NotIdempotent();
6565 :
Base(bitfield), allocation_type_(allocation_type) {}
6569 OpProperties::DeferredCall() | OpProperties::NotIdempotent();
6594 uint32_t slot_count,
ScopeType scope_type)
6596 scope_info_(scope_info),
6597 slot_count_(slot_count),
6598 scope_type_(scope_type) {}
6609 OpProperties::LazyDeopt() | OpProperties::NotIdempotent();
6632 shared_function_info_(shared_function_info),
6633 feedback_cell_(feedback_cell) {}
6636 return shared_function_info_;
6645 OpProperties::LazyDeopt() | OpProperties::NotIdempotent();
6667 :
Base(bitfield), pattern_(pattern), feedback_(feedback), flags_(
flags) {}
6698 shared_function_info_(shared_function_info),
6699 feedback_cell_(feedback_cell),
6700 pretenured_(pretenured) {}
6703 return shared_function_info_;
6713 OpProperties::NotIdempotent();
6728 #define ASSERT_CONDITION(V) \
6734 V(GreaterThanEqual) \
6735 V(UnsignedLessThan) \
6736 V(UnsignedLessThanEqual) \
6737 V(UnsignedGreaterThan) \
6738 V(UnsignedGreaterThanEqual)
6741 #define D(Name) k##Name,
6752 #define CASE(Name) \
6753 case AssertCondition::k##Name: \
6768 :
Base(bitfield), condition_(condition), reason_(reason) {}
6771 ValueRepresentation::kInt32, ValueRepresentation::kInt32};
6780 auto options()
const {
return std::tuple{condition_, reason_}; }
6801 maps_(maps.
begin(), maps.
end(), zone) {}
6804 OpProperties::EagerDeopt() | OpProperties::CanRead();
6811 static constexpr
int kReceiverIndex = 0;
6818 auto options()
const {
return std::tuple{maps_, check_type()}; }
6838 maps_(maps.
begin(), maps.
end(), zone) {}
6841 OpProperties::EagerDeopt() | OpProperties::DeferredCall() |
6843 OpProperties::CanRead();
6851 static constexpr
int kReceiverIndex = 0;
6859 auto options()
const {
return std::tuple{maps_, check_type()}; }
6873 :
Base(bitfield), maps_(maps) {}
6876 :
Base(bitfield), maps_(maps.
begin(), maps.
end(), zone) {}
6879 OpProperties::EagerDeopt() | OpProperties::CanRead();
6881 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
6892 auto options()
const {
return std::tuple{maps_}; }
6904 :
Base(bitfield | ReasonField::encode(reason)), value_(
value) {}
6912 static constexpr
int kTargetIndex = 0;
6915 #ifdef V8_COMPRESS_POINTERS
6916 void MarkTaggedInputsAsDecompressing() {
6925 auto options()
const {
return std::tuple{value_, deoptimize_reason()}; }
6939 :
Base(bitfield | ReasonField::encode(reason)), value_(
value) {}
6947 static constexpr
int kTargetIndex = 0;
6954 auto options()
const {
return std::tuple{value_, deoptimize_reason()}; }
6968 :
Base(bitfield | ReasonField::encode(reason)), value_(
value) {}
6976 static constexpr
int kTargetIndex = 0;
6979 void SetValueLocationConstraints();
6983 auto options()
const {
return std::tuple{value_, deoptimize_reason()}; }
6999 :
Base(bitfield | ReasonField::encode(reason)), value_(
value) {}
7003 OpProperties::EagerDeopt() |
7004 OpProperties::DeferredCall();
7010 static constexpr
int kTargetIndex = 0;
7018 auto options()
const {
return std::tuple{value_, deoptimize_reason()}; }
7031 :
Base(bitfield | ReasonField::encode(reason)) {}
7035 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
7037 static constexpr
int kFirstIndex = 0;
7038 static constexpr
int kSecondIndex = 1;
7042 #ifdef V8_COMPRESS_POINTERS
7043 void MarkTaggedInputsAsDecompressing() {
7052 auto options()
const {
return std::tuple{deoptimize_reason()}; }
7067 static constexpr
int kReceiverIndex = 0;
7070 using Node::set_input;
7072 #ifdef V8_COMPRESS_POINTERS
7073 void MarkTaggedInputsAsDecompressing() {
7094 static constexpr
int kReceiverIndex = 0;
7102 auto options()
const {
return std::tuple{mode_}; }
7118 static constexpr
int kReceiverIndex = 0;
7121 #ifdef V8_COMPRESS_POINTERS
7122 void MarkTaggedInputsAsDecompressing() {
7143 static constexpr
int kReceiverIndex = 0;
7151 auto options()
const {
return std::tuple{check_type()}; }
7165 first_instance_type_(first_instance_type),
7166 last_instance_type_(last_instance_type) {
7167 DCHECK_LE(first_instance_type, last_instance_type);
7174 static constexpr
int kReceiverIndex = 0;
7184 return std::tuple{check_type(), first_instance_type_, last_instance_type_};
7207 static constexpr
int kReceiverIndex = 0;
7215 auto options()
const {
return std::tuple{check_type()}; }
7232 static constexpr
int kReceiverIndex = 0;
7240 auto options()
const {
return std::tuple{check_type()}; }
7258 static constexpr
int kReceiverIndex = 0;
7266 auto options()
const {
return std::tuple{check_type()}; }
7283 static constexpr
int kReceiverIndex = 0;
7291 auto options()
const {
return std::tuple{check_type()}; }
7309 static constexpr
int kReceiverIndex = 0;
7317 auto options()
const {
return std::tuple{check_type()}; }
7334 OpProperties::EagerDeopt() | OpProperties::DeferredCall() |
7336 OpProperties::CanRead();
7342 static constexpr
int kReceiverIndex = 0;
7365 OpProperties::EagerDeopt() | OpProperties::DeferredCall() |
7367 OpProperties::CanRead();
7370 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
7372 static constexpr
int kMapIndex = 0;
7373 static constexpr
int kObjectIndex = 1;
7393 OpProperties::EagerDeopt() | OpProperties::CanRead();
7395 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
7397 static constexpr
int kEnumIndices = 0;
7399 static constexpr
int kCacheLength = 1;
7413 :
Base(bitfield), element_type_(element_type) {}
7417 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
7419 static constexpr
int kReceiverIndex = 0;
7420 static constexpr
int kIndexIndex = 1;
7424 int MaxCallStackArgs()
const;
7425 void SetValueLocationConstraints();
7429 auto options()
const {
return std::tuple{element_type_}; }
7443 :
Base(bitfield), elements_kind_(elements_kind) {}
7445 OpProperties::IntPtr() | OpProperties::CanRead();
7449 static constexpr
int kReceiverIndex = 0;
7452 void SetValueLocationConstraints();
7456 auto options()
const {
return std::tuple{elements_kind_}; }
7471 OpProperties::EagerDeopt() | OpProperties::CanRead();
7475 static constexpr
int kObjectIndex = 0;
7492 static constexpr
int kIndexIndex = 0;
7493 static constexpr
int kLengthIndex = 1;
7509 ReasonField::encode(reason)) {}
7513 ValueRepresentation::kInt32, ValueRepresentation::kInt32};
7515 static constexpr
int kLeftIndex = 0;
7516 static constexpr
int kRightIndex = 1;
7521 return ConditionField::decode(bitfield());
7528 auto options()
const {
return std::tuple{condition(), deoptimize_reason()}; }
7534 ReasonField::Next<AssertCondition, base::bits::WhichPowerOfTwo<size_t>(
7535 base::bits::RoundUpToPowerOfTwo32(
7579 OpProperties::DeferredCall() | OpProperties::NotIdempotent();
7594 CHECK_EQ(properties().value_representation(), ValueRepresentation::kTagged);
7598 OpProperties::EagerDeopt() | OpProperties::TaggedValue();
7602 static constexpr
int kObjectIndex = 0;
7610 auto options()
const {
return std::tuple{check_type()}; }
7625 OpProperties::EagerDeopt() | OpProperties::Int32() |
7626 OpProperties::DeferredCall() | OpProperties::ConversionNode();
7630 static constexpr
int kObjectIndex = 0;
7634 int MaxCallStackArgs()
const;
7639 auto options()
const {
return std::tuple{check_type()}; }
7653 shared_function_info_(shared_function_info),
7654 feedback_(feedback) {}
7658 OpProperties::GenericRuntimeOrBuiltinCall();
7665 return shared_function_info_;
7691 OpProperties::DeferredCall() | OpProperties::CanCallUserCode();
7722 int MaxCallStackArgs()
const;
7723 void SetValueLocationConstraints();
7730 BuiltinStringPrototypeCharCodeOrCodePointAt> {
7746 OpProperties::DeferredCall() | OpProperties::Int32();
7748 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
7750 static constexpr
int kStringIndex = 0;
7751 static constexpr
int kIndexIndex = 1;
7762 Mode mode()
const {
return ModeField::decode(bitfield()); }
7777 OpProperties::CanRead() | OpProperties::Int32();
7779 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
7781 static constexpr
int kStringIndex = 0;
7782 static constexpr
int kIndexIndex = 1;
7799 OpProperties::CanRead() | OpProperties::TaggedValue();
7801 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
7824 OpProperties::CanRead() |
7825 OpProperties::TaggedValue();
7827 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
7847 OpProperties::CanRead() | OpProperties::TaggedValue();
7849 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
7871 :
Base(bitfield), allocation_type_(allocation_type) {}
7899 :
Base(bitfield), fast_map_(fast_map), double_map_(double_map) {}
7902 OpProperties::AnySideEffects() | OpProperties::DeferredCall();
7904 ValueRepresentation::kTagged, ValueRepresentation::kInt32,
7905 ValueRepresentation::kTagged};
7954 compiler::OptionalJSObjectRef holder,
FieldIndex field_index) {
7974 return constant_.object();
7979 return constant_double_.get_scalar();
7984 return constant_.AsCell().object();
7987 compiler::OptionalJSObjectRef
holder()
const {
7989 return data_load_.holder_;
7994 return data_load_.field_index_;
8003 if (maps_.size() != other.
maps_.size()) {
8006 for (
size_t i = 0;
i < maps_.size(); ++
i) {
8007 if (maps_[
i] != other.
maps_[
i]) {
8017 return constant_.equals(other.
constant_);
8018 case kConstantDouble:
8021 return data_load_.holder_.equals(other.
data_load_.holder_) &&
8022 data_load_.field_index_ == other.
data_load_.field_index_;
8029 for (
auto map : maps()) {
8040 case kConstantDouble:
8057 : kind_(kind), maps_(maps), representation_(representation) {
8063 compiler::ObjectRef constant)
8066 representation_(representation),
8067 constant_(constant) {
8068 DCHECK(kind == kConstant || kind == kModuleExport);
8076 constant_double_(constant) {
8082 compiler::OptionalJSObjectRef holder,
8086 representation_(representation),
8087 data_load_{holder, field_index} {
8105 template <
typename Derived = LoadTaggedField>
8112 :
Base(bitfield), offset_(offset) {}
8121 static constexpr
int kObjectIndex = 0;
8128 auto options()
const {
return std::tuple{offset()}; }
8130 using Base::decompresses_tagged_result;
8141 :
Base(bitfield, offset) {}
8151 :
Base(bitfield, offset), name_(
name) {}
8154 auto options()
const {
return std::tuple{offset(), name_}; }
8167 :
Base(bitfield, offset) {}
8176 :
Base(bitfield), offset_(offset) {}
8180 OpProperties::DeferredCall();
8187 static constexpr
int kContextIndex = 0;
8195 auto options()
const {
return std::tuple{offset()}; }
8197 using Base::decompresses_tagged_result;
8208 :
Base(bitfield), offset_(offset) {}
8217 static constexpr
int kObjectIndex = 0;
8224 auto options()
const {
return std::tuple{offset()}; }
8235 :
Base(bitfield), offset_(offset) {}
8244 static constexpr
int kObjectIndex = 0;
8251 auto options()
const {
return std::tuple{offset()}; }
8262 :
Base(bitfield), offset_(offset) {}
8265 OpProperties::CanRead() | OpProperties::Int32();
8271 static constexpr
int kObjectIndex = 0;
8278 auto options()
const {
return std::tuple{offset()}; }
8292 OpProperties::CanRead() |
8293 OpProperties::DeferredCall();
8295 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
8297 static constexpr
int kObjectIndex = 0;
8298 static constexpr
int kIndexIndex = 1;
8302 #ifdef V8_COMPRESS_POINTERS
8303 void MarkTaggedInputsAsDecompressing() {
8305 object_input().node()->SetTaggedResultNeedsDecompress();
8324 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
8326 static constexpr
int kElementsIndex = 0;
8327 static constexpr
int kIndexIndex = 1;
8344 OpProperties::DeferredCall() |
8345 OpProperties::CanWrite();
8347 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
8349 static constexpr
int kElementsIndex = 0;
8350 static constexpr
int kObjectIndex = 1;
8366 :
Base(bitfield), old_length_(old_length) {}
8370 OpProperties::CanWrite() | OpProperties::DeferredCall() |
8371 OpProperties::EagerDeopt() | OpProperties::NotIdempotent();
8374 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
8376 static constexpr
int kPropertyArrayIndex = 0;
8377 static constexpr
int kObjectIndex = 1;
8398 :
Base(bitfield), elements_kind_(elements_kind) {}
8402 OpProperties::CanWrite() | OpProperties::EagerDeopt();
8404 ValueRepresentation::kTagged, ValueRepresentation::kTagged,
8405 ValueRepresentation::kInt32, ValueRepresentation::kInt32};
8407 static constexpr
int kElementsIndex = 0;
8408 static constexpr
int kObjectIndex = 1;
8409 static constexpr
int kIndexIndex = 2;
8410 static constexpr
int kElementsLengthIndex = 3;
8423 auto options()
const {
return std::tuple{elements_kind()}; }
8438 OpProperties::CanWrite() | OpProperties::DeferredCall();
8440 ValueRepresentation::kTagged, ValueRepresentation::kInt32,
8441 ValueRepresentation::kTagged};
8443 static constexpr
int kElementsIndex = 0;
8444 static constexpr
int kIndexIndex = 1;
8445 static constexpr
int kValueIndex = 2;
8471 OpProperties::CanWrite() | OpProperties::DeferredCall();
8473 ValueRepresentation::kTagged, ValueRepresentation::kInt32,
8474 ValueRepresentation::kTagged};
8476 static constexpr
int kElementsIndex = 0;
8477 static constexpr
int kIndexIndex = 1;
8478 static constexpr
int kValueIndex = 2;
8502 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
8504 static constexpr
int kElementsIndex = 0;
8505 static constexpr
int kIndexIndex = 1;
8525 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
8527 static constexpr
int kElementsIndex = 0;
8528 static constexpr
int kIndexIndex = 1;
8539 2, LoadHoleyFixedDoubleArrayElementCheckedNotHole> {
8549 OpProperties::EagerDeopt();
8551 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
8553 static constexpr
int kElementsIndex = 0;
8554 static constexpr
int kIndexIndex = 1;
8572 ValueRepresentation::kTagged, ValueRepresentation::kInt32,
8573 ValueRepresentation::kHoleyFloat64};
8575 static constexpr
int kElementsIndex = 0;
8576 static constexpr
int kIndexIndex = 1;
8577 static constexpr
int kValueIndex = 2;
8601 OpProperties::CanRead() | OpProperties::Int32();
8603 ValueRepresentation::kTagged, ValueRepresentation::kInt32,
8604 ValueRepresentation::kTagged};
8606 static constexpr
int kObjectIndex = 0;
8607 static constexpr
int kIndexIndex = 1;
8608 static constexpr
int kIsLittleEndianIndex = 2;
8614 return IsConstantNode(is_little_endian_input().node()->opcode());
8621 auto options()
const {
return std::tuple{type_}; }
8644 ValueRepresentation::kTagged, ValueRepresentation::kInt32,
8645 ValueRepresentation::kTagged};
8647 static constexpr
int kObjectIndex = 0;
8648 static constexpr
int kIndexIndex = 1;
8649 static constexpr
int kIsLittleEndianIndex = 2;
8655 return IsConstantNode(is_little_endian_input().node()->opcode());
8662 auto options()
const {
return std::tuple{type_}; }
8665 #define LOAD_TYPED_ARRAY(name, properties, ...) \
8666 class name : public FixedInputValueNodeT<2, name> { \
8667 using Base = FixedInputValueNodeT<2, name>; \
8670 explicit name(uint64_t bitfield, ElementsKind elements_kind) \
8671 : Base(bitfield), elements_kind_(elements_kind) { \
8672 DCHECK(elements_kind == \
8673 v8::internal::compiler::turboshaft::any_of(__VA_ARGS__)); \
8676 static constexpr OpProperties kProperties = \
8677 OpProperties::CanRead() | properties; \
8678 static constexpr typename Base::InputTypes kInputTypes{ \
8679 ValueRepresentation::kTagged, ValueRepresentation::kUint32}; \
8681 static constexpr int kObjectIndex = 0; \
8682 static constexpr int kIndexIndex = 1; \
8683 Input& object_input() { return input(kObjectIndex); } \
8684 Input& index_input() { return input(kIndexIndex); } \
8686 void SetValueLocationConstraints(); \
8687 void GenerateCode(MaglevAssembler*, const ProcessingState&); \
8688 void PrintParams(std::ostream&, MaglevGraphLabeller*) const {} \
8690 auto options() const { return std::tuple{elements_kind_}; } \
8692 ElementsKind elements_kind() const { return elements_kind_; } \
8695 ElementsKind elements_kind_; \
8708 #undef LOAD_TYPED_ARRAY
8710 #define LOAD_CONSTANT_TYPED_ARRAY(name, properties, ...) \
8711 class name : public FixedInputValueNodeT<1, name> { \
8712 using Base = FixedInputValueNodeT<1, name>; \
8715 explicit name(uint64_t bitfield, compiler::JSTypedArrayRef typed_array, \
8716 ElementsKind elements_kind) \
8718 typed_array_(typed_array), \
8719 elements_kind_(elements_kind) { \
8720 DCHECK(elements_kind == \
8721 v8::internal::compiler::turboshaft::any_of(__VA_ARGS__)); \
8724 static constexpr OpProperties kProperties = \
8725 OpProperties::CanRead() | properties; \
8727 typename Base::InputTypes kInputTypes{ValueRepresentation::kUint32}; \
8729 static constexpr int kIndexIndex = 0; \
8730 Input& index_input() { return input(kIndexIndex); } \
8732 void SetValueLocationConstraints(); \
8733 void GenerateCode(MaglevAssembler*, const ProcessingState&); \
8734 void PrintParams(std::ostream&, MaglevGraphLabeller*) const {} \
8736 auto options() const { return std::tuple{typed_array_, elements_kind_}; } \
8738 ElementsKind elements_kind() const { return elements_kind_; } \
8739 compiler::JSTypedArrayRef typed_array() const { return typed_array_; } \
8742 compiler::JSTypedArrayRef typed_array_; \
8743 ElementsKind elements_kind_; \
8759 #undef LOAD_CONSTANT_TYPED_ARRAY
8761 #define STORE_TYPED_ARRAY(name, properties, type, ...) \
8762 class name : public FixedInputNodeT<3, name> { \
8763 using Base = FixedInputNodeT<3, name>; \
8766 explicit name(uint64_t bitfield, ElementsKind elements_kind) \
8767 : Base(bitfield), elements_kind_(elements_kind) { \
8768 DCHECK(elements_kind == \
8769 v8::internal::compiler::turboshaft::any_of(__VA_ARGS__)); \
8772 static constexpr OpProperties kProperties = properties; \
8773 static constexpr typename Base::InputTypes kInputTypes{ \
8774 ValueRepresentation::kTagged, ValueRepresentation::kUint32, type}; \
8776 static constexpr int kObjectIndex = 0; \
8777 static constexpr int kIndexIndex = 1; \
8778 static constexpr int kValueIndex = 2; \
8779 Input& object_input() { return input(kObjectIndex); } \
8780 Input& index_input() { return input(kIndexIndex); } \
8781 Input& value_input() { return input(kValueIndex); } \
8783 void SetValueLocationConstraints(); \
8784 void GenerateCode(MaglevAssembler*, const ProcessingState&); \
8785 void PrintParams(std::ostream&, MaglevGraphLabeller*) const {} \
8787 ElementsKind elements_kind() const { return elements_kind_; } \
8790 ElementsKind elements_kind_; \
8800 #undef STORE_TYPED_ARRAY
8802 #define STORE_CONSTANT_TYPED_ARRAY(name, properties, type, ...) \
8803 class name : public FixedInputNodeT<2, name> { \
8804 using Base = FixedInputNodeT<2, name>; \
8807 explicit name(uint64_t bitfield, compiler::JSTypedArrayRef typed_array, \
8808 ElementsKind elements_kind) \
8810 typed_array_(typed_array), \
8811 elements_kind_(elements_kind) { \
8812 DCHECK(elements_kind == \
8813 v8::internal::compiler::turboshaft::any_of(__VA_ARGS__)); \
8816 static constexpr OpProperties kProperties = properties; \
8817 static constexpr typename Base::InputTypes kInputTypes{ \
8818 ValueRepresentation::kUint32, type}; \
8820 static constexpr int kIndexIndex = 0; \
8821 static constexpr int kValueIndex = 1; \
8822 Input& index_input() { return input(kIndexIndex); } \
8823 Input& value_input() { return input(kValueIndex); } \
8825 void SetValueLocationConstraints(); \
8826 void GenerateCode(MaglevAssembler*, const ProcessingState&); \
8827 void PrintParams(std::ostream&, MaglevGraphLabeller*) const {} \
8829 ElementsKind elements_kind() const { return elements_kind_; } \
8830 compiler::JSTypedArrayRef typed_array() const { return typed_array_; } \
8833 compiler::JSTypedArrayRef typed_array_; \
8834 ElementsKind elements_kind_; \
8838 OpProperties::CanWrite(),
8844 OpProperties::CanWrite(),
8847 #undef STORE_CONSTANT_TYPED_ARRAY
8864 ValueRepresentation::kTagged, ValueRepresentation::kInt32,
8865 ValueRepresentation::kInt32, ValueRepresentation::kTagged};
8867 static constexpr
int kObjectIndex = 0;
8868 static constexpr
int kIndexIndex = 1;
8869 static constexpr
int kValueIndex = 2;
8870 static constexpr
int kIsLittleEndianIndex = 3;
8877 return IsConstantNode(is_little_endian_input().node()->opcode());
8902 ValueRepresentation::kTagged, ValueRepresentation::kInt32,
8903 ValueRepresentation::kHoleyFloat64, ValueRepresentation::kTagged};
8905 static constexpr
int kObjectIndex = 0;
8906 static constexpr
int kIndexIndex = 1;
8907 static constexpr
int kValueIndex = 2;
8908 static constexpr
int kIsLittleEndianIndex = 3;
8915 return IsConstantNode(is_little_endian_input().node()->opcode());
8928 :
Base(bitfield), offset_(offset) {}
8932 ValueRepresentation::kTagged, ValueRepresentation::kFloat64};
8936 static constexpr
int kObjectIndex = 0;
8937 static constexpr
int kValueIndex = 1;
8954 :
Base(bitfield), offset_(offset) {}
8958 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
8962 static constexpr
int kObjectIndex = 0;
8963 static constexpr
int kValueIndex = 1;
8980 :
Base(bitfield), offset_(offset) {}
8984 ValueRepresentation::kTagged, ValueRepresentation::kFloat64};
8988 static constexpr
int kObjectIndex = 0;
8989 static constexpr
int kValueIndex = 1;
9007 return mode == StoreTaggedMode::kInitializing ||
9008 mode == StoreTaggedMode::kTransitioning;
9029 OpProperties::CanWrite() | OpProperties::DeferredCall();
9031 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
9035 return InitializingOrTransitioningField::decode(bitfield());
9038 static constexpr
int kObjectIndex = 0;
9039 static constexpr
int kValueIndex = 1;
9043 #ifdef V8_COMPRESS_POINTERS
9044 void MarkTaggedInputsAsDecompressing() {
9045 object_input().node()->SetTaggedResultNeedsDecompress();
9079 OpProperties::CanWrite() | OpProperties::DeferredCall();
9083 static constexpr
int kObjectIndex = 0;
9087 Kind kind()
const {
return KindField::decode(bitfield()); }
9114 OpProperties::CanWrite() | OpProperties::DeferredCall();
9116 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
9120 return InitializingOrTransitioningField::decode(bitfield());
9123 static constexpr
int kObjectIndex = 0;
9124 static constexpr
int kValueIndex = 1;
9128 #ifdef V8_COMPRESS_POINTERS
9129 void MarkTaggedInputsAsDecompressing() {
9130 object_input().node()->SetTaggedResultNeedsDecompress();
9155 OpProperties::DeferredCall() |
9156 OpProperties::LazyDeopt();
9158 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
9163 static constexpr
int kContextIndex = 0;
9164 static constexpr
int kNewValueIndex = 1;
9168 #ifdef V8_COMPRESS_POINTERS
9169 void MarkTaggedInputsAsDecompressing() {
9170 context_input().node()->SetTaggedResultNeedsDecompress();
9171 new_value_input().node()->SetTaggedResultNeedsDecompress();
9185 :
public FixedInputNodeT<2, StoreTrustedPointerFieldWithWriteBarrier> {
9199 OpProperties::CanWrite() | OpProperties::DeferredCall();
9201 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
9206 return InitializingOrTransitioningField::decode(bitfield());
9209 static constexpr
int kObjectIndex = 0;
9210 static constexpr
int kValueIndex = 1;
9214 #ifdef V8_COMPRESS_POINTERS
9215 void MarkTaggedInputsAsDecompressing() {
9216 object_input().node()->SetTaggedResultNeedsDecompress();
9242 feedback_(feedback),
9243 typeof_mode_(typeof_mode) {}
9273 :
Base(bitfield), name_(
name), feedback_(feedback) {}
9278 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
9305 ValueRepresentation::kInt32, ValueRepresentation::kTagged,
9306 ValueRepresentation::kInt32};
9312 static constexpr
int kLengthIndex = 0;
9313 static constexpr
int kObjectIndex = 1;
9314 static constexpr
int kIndexIndex = 2;
9330 :
Base(bitfield), name_(
name), feedback_(feedback) {}
9335 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
9340 static constexpr
int kContextIndex = 0;
9341 static constexpr
int kObjectIndex = 1;
9362 :
Base(bitfield), name_(
name), feedback_(feedback) {}
9367 ValueRepresentation::kTagged, ValueRepresentation::kTagged,
9368 ValueRepresentation::kTagged};
9373 static constexpr
int kContextIndex = 0;
9374 static constexpr
int kReceiverIndex = 1;
9375 static constexpr
int kLookupStartObjectIndex = 2;
9396 :
Base(bitfield), name_(
name), feedback_(feedback) {}
9401 ValueRepresentation::kTagged, ValueRepresentation::kTagged,
9402 ValueRepresentation::kTagged};
9407 static constexpr
int kContextIndex = 0;
9408 static constexpr
int kObjectIndex = 1;
9409 static constexpr
int kValueIndex = 2;
9432 OpProperties::CanRead() | OpProperties::Int32();
9436 static constexpr
int kMapInput = 0;
9452 OpProperties::DeferredCall();
9454 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
9456 static constexpr
int kStringIndex = 0;
9457 static constexpr
int kIndexIndex = 1;
9475 ValueRepresentation::kTagged, ValueRepresentation::kInt32};
9477 static constexpr
int kStringIndex = 0;
9478 static constexpr
int kIndexIndex = 1;
9494 OpProperties::CanRead() | OpProperties::Int32();
9498 static constexpr
int kObjectIndex = 0;
9517 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
9547 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
9552 #ifdef V8_STATIC_ROOTS
9553 void MarkTaggedInputsAsDecompressing()
const {
9591 :
Base(bitfield), name_(
name), feedback_(feedback) {}
9596 ValueRepresentation::kTagged, ValueRepresentation::kTagged,
9597 ValueRepresentation::kTagged};
9602 static constexpr
int kContextIndex = 0;
9603 static constexpr
int kObjectIndex = 1;
9604 static constexpr
int kValueIndex = 2;
9626 :
Base(bitfield), feedback_(feedback) {}
9631 ValueRepresentation::kTagged, ValueRepresentation::kTagged,
9632 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
9636 static constexpr
int kContextIndex = 0;
9637 static constexpr
int kObjectIndex = 1;
9638 static constexpr
int kNameIndex = 2;
9639 static constexpr
int kValueIndex = 3;
9660 :
Base(bitfield), feedback_(feedback) {}
9665 ValueRepresentation::kTagged, ValueRepresentation::kTagged,
9666 ValueRepresentation::kTagged};
9670 static constexpr
int kContextIndex = 0;
9671 static constexpr
int kObjectIndex = 1;
9672 static constexpr
int kKeyIndex = 2;
9692 :
Base(bitfield), feedback_(feedback) {}
9697 ValueRepresentation::kTagged, ValueRepresentation::kTagged,
9698 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
9702 static constexpr
int kContextIndex = 0;
9703 static constexpr
int kObjectIndex = 1;
9704 static constexpr
int kKeyIndex = 2;
9705 static constexpr
int kValueIndex = 3;
9727 :
Base(bitfield), feedback_(feedback) {}
9732 ValueRepresentation::kTagged, ValueRepresentation::kTagged,
9733 ValueRepresentation::kTagged, ValueRepresentation::kTagged,
9734 ValueRepresentation::kTagged};
9738 static constexpr
int kContextIndex = 0;
9739 static constexpr
int kObjectIndex = 1;
9740 static constexpr
int kKeyIndex = 2;
9741 static constexpr
int kValueIndex = 3;
9742 static constexpr
int kFlagsIndex = 4;
9764 :
Base(bitfield), source_(source), target_(target) {}
9784 :
Base(bitfield), node_(node), target_(target) {}
9819 case UseRepresentation::kTagged:
9820 return os <<
"Tagged";
9821 case UseRepresentation::kInt32:
9822 return os <<
"Int32";
9823 case UseRepresentation::kTruncatedInt32:
9824 return os <<
"TruncatedInt32";
9825 case UseRepresentation::kUint32:
9826 return os <<
"Uint32";
9827 case UseRepresentation::kFloat64:
9828 return os <<
"Float64";
9829 case UseRepresentation::kHoleyFloat64:
9830 return os <<
"HoleyFloat64";
9851 merge_state_(merge_state),
9861 return merge_state_;
9864 using Node::initialize_input_null;
9865 using Node::reduce_input_count;
9866 using Node::set_input;
9869 bool is_loop_phi()
const;
9877 #ifdef V8_COMPRESS_POINTERS
9878 void MarkTaggedInputsAsDecompressing() {
9899 return same_loop_uses_repr_hint_;
9909 DCHECK(is_unmerged_loop_phi());
9910 post_loop_type_ =
type;
9914 DCHECK(is_unmerged_loop_phi());
9916 type_ = post_loop_type_;
9938 set_bitfield(bitfield() | HasKeyFlag::encode(
true));
9943 bool has_key()
const {
return HasKeyFlag::decode(bitfield()); }
9947 void SetUseRequires31BitValue();
9949 return Requires31BitValueFlag::decode(bitfield());
9952 set_bitfield(bitfield() | Requires31BitValueFlag::encode(
true));
9956 bool is_unmerged_loop_phi()
const;
10001 static constexpr
int kFunctionIndex = 0;
10002 static constexpr
int kContextIndex = 1;
10003 static constexpr
int kFixedInputCount = 2;
10007 static_assert(kMaxInputs >= kFixedInputCount + Code::kMaxArguments);
10013 :
Base(bitfield), receiver_mode_(
mode), target_type_(target_type) {
10014 set_input(kFunctionIndex,
function);
10015 set_input(kContextIndex, context);
10020 Input&
function() {
return input(kFunctionIndex); }
10021 const Input&
function()
const {
return input(kFunctionIndex); }
10027 set_input(
i + kFixedInputCount, node);
10031 std::make_reverse_iterator(&arg(-1)),
10032 std::make_reverse_iterator(&arg(num_args() - 1)));
10036 #ifdef V8_COMPRESS_POINTERS
10037 void MarkTaggedInputsAsDecompressing();
10057 static constexpr
int kFunctionIndex = 0;
10058 static constexpr
int kNewTargetIndex = 1;
10059 static constexpr
int kContextIndex = 2;
10060 static constexpr
int kFixedInputCount = 3;
10064 static_assert(kMaxInputs >= kFixedInputCount + Code::kMaxArguments);
10070 :
Base(bitfield), feedback_(feedback) {
10071 set_input(kFunctionIndex,
function);
10072 set_input(kNewTargetIndex, new_target);
10073 set_input(kContextIndex, context);
10078 Input&
function() {
return input(kFunctionIndex); }
10079 const Input&
function()
const {
return input(kFunctionIndex); }
10087 set_input(
i + kFixedInputCount, node);
10091 std::make_reverse_iterator(&arg(-1)),
10092 std::make_reverse_iterator(&arg(num_args() - 1)));
10098 #ifdef V8_COMPRESS_POINTERS
10099 void MarkTaggedInputsAsDecompressing();
10119 :
Base(bitfield), builtin_(builtin) {
10121 !Builtins::CallInterfaceDescriptorFor(builtin).HasContextParameter());
10127 :
Base(bitfield), builtin_(builtin) {
10128 DCHECK(Builtins::CallInterfaceDescriptorFor(builtin).HasContextParameter());
10139 return feedback_.value();
10147 feedback_ = feedback;
10148 slot_type_ = slot_type;
10154 Builtins::CallInterfaceDescriptorFor(builtin()).HasContextParameter());
10159 auto descriptor = Builtins::CallInterfaceDescriptorFor(builtin_);
10160 bool has_context = descriptor.HasContextParameter();
10161 int extra_input_count = has_context ? 1 : 0;
10166 auto descriptor = Builtins::CallInterfaceDescriptorFor(builtin_);
10167 if (has_feedback()) {
10168 int slot_index = InputCountWithoutContext();
10169 int vector_index = slot_index + 1;
10175 if (vector_index < descriptor.GetRegisterParameterCount()) {
10176 return descriptor.GetRegisterParameterCount() - 2;
10177 }
else if (vector_index == descriptor.GetRegisterParameterCount()) {
10178 return descriptor.GetRegisterParameterCount() - 1;
10180 return descriptor.GetRegisterParameterCount();
10183 return descriptor.GetRegisterParameterCount();
10188 std::make_reverse_iterator(&input(InputsInRegisterCount() - 1)),
10189 std::make_reverse_iterator(&input(InputCountWithoutContext() - 1)));
10195 return Builtins::CallInterfaceDescriptorFor(builtin_).GetReturnCount();
10199 #ifdef V8_COMPRESS_POINTERS
10200 void MarkTaggedInputsAsDecompressing();
10208 template <
typename... Args>
10222 Builtin::kCEntry_Return1_ArgvOnStack_BuiltinExit;
10225 static constexpr
int kTargetIndex = 0;
10226 static constexpr
int kNewTargetIndex = 1;
10227 static constexpr
int kContextIndex = 2;
10228 static constexpr
int kFixedInputCount = 3;
10232 :
Base(bitfield), builtin_(builtin) {
10233 DCHECK(Builtins::CallInterfaceDescriptorFor(builtin).HasContextParameter());
10234 DCHECK_EQ(Builtins::CallInterfaceDescriptorFor(builtin).GetReturnCount(),
10236 set_input(kTargetIndex, target);
10237 set_input(kNewTargetIndex, new_target);
10238 set_input(kContextIndex, context);
10256 set_input(
i + kFixedInputCount, node);
10261 std::make_reverse_iterator(&arg(-1)),
10262 std::make_reverse_iterator(&arg(num_args() - 1)));
10266 #ifdef V8_COMPRESS_POINTERS
10267 void MarkTaggedInputsAsDecompressing();
10282 static constexpr
int kFunctionIndex = 0;
10283 static constexpr
int kContextIndex = 1;
10284 static constexpr
int kFixedInputCount = 2;
10288 static_assert(kMaxInputs >= kFixedInputCount + Code::kMaxArguments);
10294 :
Base(bitfield), start_index_(start_index), target_type_(target_type) {
10295 set_input(kFunctionIndex,
function);
10296 set_input(kContextIndex, context);
10301 Input&
function() {
return input(kFunctionIndex); }
10302 const Input&
function()
const {
return input(kFunctionIndex); }
10308 set_input(
i + kFixedInputCount, node);
10312 std::make_reverse_iterator(&arg(-1)),
10313 std::make_reverse_iterator(&arg(num_args() - 1)));
10317 #ifdef V8_COMPRESS_POINTERS
10318 void MarkTaggedInputsAsDecompressing();
10338 static constexpr
int kContextIndex = 0;
10339 static constexpr
int kFixedInputCount = 1;
10345 :
Base(bitfield), function_id_(function_id) {
10346 set_input(kContextIndex, context);
10358 set_input(
i + kFixedInputCount, node);
10362 std::make_reverse_iterator(&arg(-1)),
10363 std::make_reverse_iterator(&arg(num_args() - 1)));
10367 return Runtime::FunctionForId(function_id())->result_size;
10371 #ifdef V8_COMPRESS_POINTERS
10372 void MarkTaggedInputsAsDecompressing();
10388 static constexpr
int kFunctionIndex = 0;
10389 static constexpr
int kContextIndex = 1;
10390 static constexpr
int kFixedInputCount = 2;
10396 set_input(kFunctionIndex,
function);
10397 set_input(kContextIndex, context);
10402 Input&
function() {
return input(kFunctionIndex); }
10403 const Input&
function()
const {
return input(kFunctionIndex); }
10409 return num_args() - 1;
10413 set_input(
i + kFixedInputCount, node);
10417 std::make_reverse_iterator(&arg(-1)),
10418 std::make_reverse_iterator(&arg(num_args_no_spread() - 1)));
10427 #ifdef V8_COMPRESS_POINTERS
10428 void MarkTaggedInputsAsDecompressing();
10441 static constexpr
int kFunctionIndex = 0;
10442 static constexpr
int kReceiverIndex = 1;
10443 static constexpr
int kArgumentsListIndex = 2;
10444 static constexpr
int kContextIndex = 3;
10452 ValueRepresentation::kTagged, ValueRepresentation::kTagged,
10453 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
10455 Input&
function() {
return input(kFunctionIndex); }
10461 #ifdef V8_COMPRESS_POINTERS
10462 void MarkTaggedInputsAsDecompressing();
10474 static constexpr
int kClosureIndex = 0;
10475 static constexpr
int kContextIndex = 1;
10476 static constexpr
int kReceiverIndex = 2;
10477 static constexpr
int kNewTargetIndex = 3;
10478 static constexpr
int kFixedInputCount = 4;
10482 static_assert(kMaxInputs >= kFixedInputCount + Code::kMaxArguments);
10488 :
Base(bitfield), expected_parameter_count_(expected_parameter_count) {
10489 set_input(kClosureIndex, closure);
10490 set_input(kContextIndex, context);
10491 set_input(kReceiverIndex, receiver);
10492 set_input(kNewTargetIndex, new_target);
10508 set_input(
i + kFixedInputCount, node);
10512 std::make_reverse_iterator(&arg(-1)),
10513 std::make_reverse_iterator(&arg(num_args() - 1)));
10517 #ifdef V8_COMPRESS_POINTERS
10518 void MarkTaggedInputsAsDecompressing();
10533 static constexpr
int kClosureIndex = 0;
10534 static constexpr
int kContextIndex = 1;
10535 static constexpr
int kReceiverIndex = 2;
10536 static constexpr
int kNewTargetIndex = 3;
10537 static constexpr
int kFixedInputCount = 4;
10541 static_assert(kMaxInputs >= kFixedInputCount + Code::kMaxArguments);
10547 #ifdef V8_ENABLE_LEAPTIERING
10566 set_input(
i + kFixedInputCount, node);
10570 std::make_reverse_iterator(&arg(-1)),
10571 std::make_reverse_iterator(&arg(num_args() - 1)));
10575 return shared_function_info_;
10579 #ifdef V8_COMPRESS_POINTERS
10580 void MarkTaggedInputsAsDecompressing();
10590 #ifdef V8_ENABLE_LEAPTIERING
10612 static constexpr
int kContextIndex = 0;
10613 static constexpr
int kReceiverIndex = 1;
10614 static constexpr
int kFixedInputCount = 2;
10618 static_assert(kMaxInputs >= kFixedInputCount + Code::kMaxArguments);
10626 function_template_info_(function_template_info) {
10627 set_input(kContextIndex, context);
10628 set_input(kReceiverIndex, receiver);
10644 set_input(
i + kFixedInputCount, node);
10648 std::make_reverse_iterator(&arg(-1)),
10649 std::make_reverse_iterator(&arg(num_args() - 1)));
10652 Mode mode()
const {
return ModeField::decode(bitfield()); }
10655 return function_template_info_;
10661 #ifdef V8_COMPRESS_POINTERS
10662 void MarkTaggedInputsAsDecompressing();
10684 static constexpr
int kFunctionIndex = 0;
10685 static constexpr
int kNewTargetIndex = 1;
10686 static constexpr
int kContextIndex = 2;
10687 static constexpr
int kFixedInputCount = 3;
10694 :
Base(bitfield), feedback_(feedback) {
10695 set_input(kFunctionIndex,
function);
10696 set_input(kNewTargetIndex, new_target);
10697 set_input(kContextIndex, context);
10702 Input&
function() {
return input(kFunctionIndex); }
10703 const Input&
function()
const {
return input(kFunctionIndex); }
10711 return num_args() - 1;
10715 set_input(
i + kFixedInputCount, node);
10723 std::make_reverse_iterator(&arg(-1)),
10724 std::make_reverse_iterator(&arg(num_args_no_spread() - 1)));
10729 #ifdef V8_COMPRESS_POINTERS
10730 void MarkTaggedInputsAsDecompressing();
10755 OpProperties::NotIdempotent();
10764 auto options()
const {
return std::tuple{native_context_, mode_}; }
10785 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
10804 OpProperties::DeferredCall();
10836 auto options()
const {
return std::tuple{check_type()}; }
10902 OpProperties::LazyDeopt() |
10903 OpProperties::NotIdempotent();
10917 :
Base(bitfield), amount_(amount) {
10926 OpProperties::LazyDeopt() | OpProperties::NotIdempotent();
10932 int MaxCallStackArgs()
const;
10933 void SetValueLocationConstraints();
10947 :
Base(bitfield), amount_(amount) {
10955 OpProperties::DeferredCall() | OpProperties::NotIdempotent();
10961 int MaxCallStackArgs()
const;
10962 void SetValueLocationConstraints();
11025 :
Base(bitfield) {}
11069 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
11072 Input&
function() {
return Node::input(1); }
11089 transition_sources_(transition_sources),
11090 transition_target_(transition_target) {}
11094 OpProperties::AnySideEffects() | OpProperties::DeferredCall();
11096 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
11107 return transition_sources_;
11110 return transition_target_;
11127 transition_sources_(transition_sources),
11128 transition_target_(transition_target) {}
11132 OpProperties::DeferredCall() |
11133 OpProperties::EagerDeopt();
11135 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
11146 return transition_sources_;
11149 return transition_target_;
11163 :
Base(bitfield) {}
11170 OpProperties::CanRead() | OpProperties::TaggedValue();
11179 :
Base(bitfield) {}
11202 return next_post_dominating_hole_;
11208 next_post_dominating_hole_ = node;
11212 using NodeBase::NodeBase;
11235 int predecessor_id_ = 0;
11238 template <
class Derived>
11247 bitfield, target_refs) {}
11263 if_true_(if_true_refs),
11264 if_false_(if_false_refs) {}
11282 template <
size_t InputCount,
class Derived>
11293 template <
size_t InputCount,
class Derived>
11302 bitfield, if_true_refs, if_false_refs) {}
11310 :
Base(bitfield, target_refs) {}
11323 :
Base(bitfield, target_refs) {}
11326 OpProperties::DeoptCheckpoint() | Base::kProperties;
11338 :
Base(bitfield, target) {}
11341 :
Base(bitfield, ref) {}
11349 used_node_locations_ = locations;
11361 :
Base(bitfield), reason_(reason) {
11362 DCHECK_EQ(NodeBase::opcode(), opcode_of<Abort>);
11383 DCHECK_EQ(NodeBase::opcode(), opcode_of<Return>);
11391 void SetValueLocationConstraints();
11401 :
Base(bitfield | ReasonField::encode(reason)) {
11402 DCHECK_EQ(NodeBase::opcode(), opcode_of<Deopt>);
11421 value_base_(value_base),
11429 value_base_(value_base),
11432 fallthrough_(fallthrough) {}
11443 DCHECK(has_fallthrough());
11444 return fallthrough_.value().block_ptr();
11448 DCHECK(has_fallthrough());
11449 fallthrough_.value().set_block_ptr(fallthrough);
11471 :
Base(bitfield, if_true_refs, if_false_refs) {}
11478 #ifdef V8_COMPRESS_POINTERS
11479 void MarkTaggedInputsAsDecompressing() {
11497 :
Base(bitfield, if_true_refs, if_false_refs), root_index_(root_index) {}
11505 #ifdef V8_COMPRESS_POINTERS
11506 void MarkTaggedInputsAsDecompressing() {
11527 :
Base(bitfield, if_true_refs, if_false_refs) {}
11534 #ifdef V8_COMPRESS_POINTERS
11535 void MarkTaggedInputsAsDecompressing() {
11576 :
Base(bitfield, if_true_refs, if_false_refs) {}
11621 :
Base(bitfield, if_true_refs, if_false_refs) {}
11641 :
Base(bitfield, if_true_refs, if_false_refs) {}
11661 :
Base(bitfield, if_true_refs, if_false_refs) {}
11673 #ifdef V8_ENABLE_EXPERIMENTAL_UNDEFINED_DOUBLE
11674 class BranchIfFloat64IsUndefinedOrHole
11675 :
public BranchControlNodeT<1, BranchIfFloat64IsUndefinedOrHole> {
11676 using Base = BranchControlNodeT<1, BranchIfFloat64IsUndefinedOrHole>;
11679 explicit BranchIfFloat64IsUndefinedOrHole(uint64_t bitfield,
11680 BasicBlockRef* if_true_refs,
11681 BasicBlockRef* if_false_refs)
11682 : Base(bitfield, if_true_refs, if_false_refs) {}
11685 typename Base::InputTypes kInputTypes{ValueRepresentation::kHoleyFloat64};
11687 Input& condition_input() {
return input(0); }
11689 void SetValueLocationConstraints();
11690 void GenerateCode(MaglevAssembler*,
const ProcessingState&);
11691 void PrintParams(std::ostream&, MaglevGraphLabeller*)
const {}
11702 :
Base(bitfield, if_true_refs, if_false_refs) {}
11719 static constexpr
int kLeftIndex = 0;
11720 static constexpr
int kRightIndex = 1;
11727 :
Base(bitfield, if_true_refs, if_false_refs), operation_(operation) {}
11730 ValueRepresentation::kInt32, ValueRepresentation::kInt32};
11747 static constexpr
int kLeftIndex = 0;
11748 static constexpr
int kRightIndex = 1;
11755 :
Base(bitfield, if_true_refs, if_false_refs), operation_(operation) {}
11758 ValueRepresentation::kUint32, ValueRepresentation::kUint32};
11775 static constexpr
int kLeftIndex = 0;
11776 static constexpr
int kRightIndex = 1;
11783 :
Base(bitfield, if_true_refs, if_false_refs), operation_(operation) {}
11786 ValueRepresentation::kFloat64, ValueRepresentation::kFloat64};
11803 static constexpr
int kLeftIndex = 0;
11804 static constexpr
int kRightIndex = 1;
11811 :
Base(bitfield, if_true_refs, if_false_refs) {}
11814 ValueRepresentation::kTagged, ValueRepresentation::kTagged};
11816 #ifdef V8_COMPRESS_POINTERS
11817 void MarkTaggedInputsAsDecompressing() {
11831 static constexpr
int kValueIndex = 0;
11838 :
Base(bitfield, if_true_refs, if_false_refs), literal_(literal) {}
11854 case Opcode::k##op: \
11855 return op::kProperties;
11861 template <
typename Function>
11862 inline void NodeBase::ForAllInputsInRegallocAssignmentOrder(
Function&& f) {
11864 for (
Input& input : *
this) {
11865 switch (compiler::UnallocatedOperand::cast(input.
operand())
11866 .extended_policy()) {
11867 case compiler::UnallocatedOperand::MUST_HAVE_REGISTER:
11868 if (category == InputAllocationPolicy::kArbitraryRegister)
11869 f(category, &input);
11872 case compiler::UnallocatedOperand::REGISTER_OR_SLOT_OR_CONSTANT:
11873 if (category == InputAllocationPolicy::kAny) f(category, &input);
11876 case compiler::UnallocatedOperand::FIXED_REGISTER:
11877 case compiler::UnallocatedOperand::FIXED_FP_REGISTER:
11878 if (category == InputAllocationPolicy::kFixedRegister)
11879 f(category, &input);
11882 case compiler::UnallocatedOperand::REGISTER_OR_SLOT:
11883 case compiler::UnallocatedOperand::SAME_AS_INPUT:
11885 case compiler::UnallocatedOperand::MUST_HAVE_SLOT:
11891 iterate_inputs(InputAllocationPolicy::kFixedRegister);
11892 iterate_inputs(InputAllocationPolicy::kArbitraryRegister);
11893 iterate_inputs(InputAllocationPolicy::kAny);
#define SBXCHECK_LT(lhs, rhs)
#define SLOW_DCHECK(condition)
A JavaScript function object (ECMA-262, 15.3).
A JavaScript value representing a 32-bit signed integer.
A JavaScript value representing a 32-bit unsigned integer.
static constexpr int kLastUsedBit
static constexpr T decode(U value)
static constexpr bool is_valid(T value)
static constexpr U encode(T value)
static constexpr U update(U previous, T value)
static constexpr int kShift
constexpr const auto & get() const
constexpr Tag tag() const
static BytecodeOffset GetContinuationBytecodeOffset(Builtin builtin)
static constexpr BytecodeOffset None()
double get_scalar() const
constexpr static MachineRepresentation PointerRepresentation()
static V8_EXPORT_PRIVATE bool BooleanValue(Tagged< Object > obj, IsolateT *isolate)
static constexpr int SizeFor(int length)
constexpr RegisterT first() const
constexpr void set(RegisterT reg)
constexpr bool has(RegisterT reg) const
constexpr void clear(RegisterT reg)
constexpr unsigned Count() const
constexpr int8_t code() const
static constexpr bool IsValid(T value) requires(std
static constexpr Tagged< Smi > FromInt(int value)
static constexpr bool IsValid(intptr_t value)
T * AllocateArray(size_t length)
void * Allocate(size_t size)
IndirectHandle< HeapObject > object() const
bool IsDoubleRegister() const
bool IsAnyStackSlot() const
bool IsAnyRegister() const
static LocationOperand * cast(InstructionOperand *op)
Register GetRegister() const
DoubleRegister GetDoubleRegister() const
bool IsSeqStringMap() const
bool IsNullMap(JSHeapBroker *broker) const
bool IsStringWrapperMap() const
bool IsBooleanMap(JSHeapBroker *broker) const
bool IsUndefinedMap(JSHeapBroker *broker) const
bool IsOneByteStringMap() const
constexpr bool is_valid() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const AbortReason reason_
void SetValueLocationConstraints()
int MaxCallStackArgs() const
Abort(uint64_t bitfield, AbortReason reason)
AbortReason reason() const
AbstractLoadTaggedField(uint64_t bitfield, const int offset)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
int MaxCallStackArgs() const
void SetValueLocationConstraints()
AllocateElementsArray(uint64_t bitfield, AllocationType allocation_type)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
AllocationType allocation_type_
AllocationType allocation_type() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
int MaxCallStackArgs() const
InlinedAllocation::List allocation_list_
InlinedAllocation::List & allocation_list()
void set_elided_write_barriers_depend_on_type()
AllocationType allocation_type() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void Add(InlinedAllocation *alloc)
AllocationBlock(uint64_t bitfield, AllocationType allocation_type)
bool elided_write_barriers_depend_on_type() const
void SetValueLocationConstraints()
AllocationType allocation_type_
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CreateArgumentsType type_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
ArgumentsElements(uint64_t bitfield, CreateArgumentsType type, int formal_parameter_count)
int formal_parameter_count_
CreateArgumentsType type() const
void SetValueLocationConstraints()
int formal_parameter_count() const
Input & arguments_count_input()
ArgumentsLength(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
AssertCondition condition_
AssertCondition condition() const
AbortReason reason() const
AssertInt32(uint64_t bitfield, AssertCondition condition, AbortReason reason)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void Bind(BasicBlock *block)
void set_block_ptr(BasicBlock *block)
BasicBlockRef(const BasicBlockRef &)=delete
BasicBlockRef & operator=(BasicBlockRef &&)=delete
BasicBlockRef * next_ref_
BasicBlockRef * next_ref() const
BasicBlockRef(BasicBlockRef &&)=delete
BasicBlockRef(BasicBlock *block)
BasicBlockRef * SetToBlockAndReturnNext(BasicBlock *block)
BasicBlockRef * MoveToRefList(BasicBlockRef *ref_list_head)
BasicBlockRef(BasicBlockRef *ref_list_head)
BasicBlock * block_ptr() const
BasicBlockRef & operator=(const BasicBlockRef &)=delete
static constexpr int kLeftIndex
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
static constexpr OpProperties kProperties
BinaryWithFeedbackNode(uint64_t bitfield, const compiler::FeedbackSource &feedback)
compiler::FeedbackSource feedback() const
void SetValueLocationConstraints()
static constexpr int kRightIndex
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const compiler::FeedbackSource feedback_
BranchControlNodeT(uint64_t bitfield, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
void set_if_true(BasicBlock *block)
BasicBlock * if_true() const
BasicBlock * if_false() const
void set_if_false(BasicBlock *block)
BranchControlNode(uint64_t bitfield, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
BranchIfFloat64Compare(uint64_t bitfield, Operation operation, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
Operation operation() const
void SetValueLocationConstraints()
Input & condition_input()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
BranchIfFloat64IsHole(uint64_t bitfield, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Input & condition_input()
BranchIfFloat64ToBooleanTrue(uint64_t bitfield, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void SetValueLocationConstraints()
BranchIfInt32Compare(uint64_t bitfield, Operation operation, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
Operation operation() const
BranchIfInt32ToBooleanTrue(uint64_t bitfield, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
Input & condition_input()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
Input & condition_input()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
BranchIfIntPtrToBooleanTrue(uint64_t bitfield, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Input & condition_input()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
BranchIfJSReceiver(uint64_t bitfield, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
BranchIfReferenceEqual(uint64_t bitfield, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
Input & condition_input()
void SetValueLocationConstraints()
BranchIfRootConstant(uint64_t bitfield, RootIndex root_index, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
BranchIfSmi(uint64_t bitfield, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
void SetValueLocationConstraints()
Input & condition_input()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
CheckType check_type() const
NextBitField< CheckType, 1 > CheckTypeBitField
BranchIfToBooleanTrue(uint64_t bitfield, CheckType check_type, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
Input & condition_input()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
BranchIfTypeOf(uint64_t bitfield, interpreter::TestTypeOfFlags::LiteralFlag literal, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
interpreter::TestTypeOfFlags::LiteralFlag literal_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
Operation operation() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
BranchIfUint32Compare(uint64_t bitfield, Operation operation, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
BranchIfUndefinedOrNull(uint64_t bitfield, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
Input & condition_input()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void SetValueLocationConstraints()
CheckType check_type() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Input & condition_input()
NextBitField< CheckType, 1 > CheckTypeBitField
BranchIfUndetectable(uint64_t bitfield, CheckType check_type, BasicBlockRef *if_true_refs, BasicBlockRef *if_false_refs)
base::Vector< ValueNode * > parameters() const
const BuiltinContinuationFrameData & data() const
BuiltinContinuationFrameData & data()
ValueNode * context() const
BuiltinContinuationDeoptFrame(Builtin builtin_id, base::Vector< ValueNode * > parameters, ValueNode *context, compiler::OptionalJSFunctionRef maybe_js_target, DeoptFrame *parent)
bool is_javascript() const
compiler::JSFunctionRef javascript_target() const
const Builtin & builtin_id() const
void SetValueLocationConstraints()
BuiltinSeqOneByteStringCharCodeAt(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
BuiltinStringFromCharCode(uint64_t bitfield)
BuiltinStringPrototypeCharCodeOrCodePointAt(uint64_t bitfield, Mode mode)
NextBitField< Mode, 1 > ModeField
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void PushFeedbackAndArguments(MaglevAssembler *)
compiler::FeedbackSource feedback() const
CallBuiltin(uint64_t bitfield, Builtin builtin, ValueNode *context)
void SetValueLocationConstraints()
int InputCountWithoutContext() const
int MaxCallStackArgs() const
FeedbackSlotType slot_type() const
void set_arg(int i, ValueNode *node)
void PassFeedbackSlotInRegister(MaglevAssembler *)
void set_feedback(compiler::FeedbackSource const &feedback, FeedbackSlotType slot_type)
CallBuiltin(uint64_t bitfield, Builtin builtin)
void PushArguments(MaglevAssembler *masm, Args... extra_args)
std::optional< compiler::FeedbackSource > feedback_
bool has_feedback() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int InputsInRegisterCount() const
int MaxCallStackArgs() const
const Input & context() const
const Input & new_target() const
void set_arg(int i, ValueNode *node)
CallCPPBuiltin(uint64_t bitfield, Builtin builtin, ValueNode *target, ValueNode *new_target, ValueNode *context)
const Input & target() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
Call::TargetType target_type_
void SetValueLocationConstraints()
void set_arg(int i, ValueNode *node)
Call::TargetType target_type() const
const Input & context() const
int MaxCallStackArgs() const
CallForwardVarargs(uint64_t bitfield, ValueNode *function, ValueNode *context, int start_index, Call::TargetType target_type)
void set_arg(int i, ValueNode *node)
const Input & context() const
const compiler::OptionalJSObjectRef api_holder_
compiler::FunctionTemplateInfoRef function_template_info() const
const Input & receiver() const
void SetValueLocationConstraints()
bool inline_builtin() const
int MaxCallStackArgs() const
void GenerateCallApiCallbackOptimizedInline(MaglevAssembler *masm, const ProcessingState &state)
NextBitField< Mode, 2 > ModeField
const compiler::FunctionTemplateInfoRef function_template_info_
CallKnownApiFunction(uint64_t bitfield, Mode mode, compiler::FunctionTemplateInfoRef function_template_info, ValueNode *context, ValueNode *receiver)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
compiler::SharedFunctionInfoRef shared_function_info() const
void set_arg(int i, ValueNode *node)
const Input & closure() const
int expected_parameter_count() const
const Input & context() const
int MaxCallStackArgs() const
int expected_parameter_count_
void SetValueLocationConstraints()
const Input & receiver() const
const compiler::SharedFunctionInfoRef shared_function_info_
const Input & new_target() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
Runtime::FunctionId function_id() const
const Input & context() const
Runtime::FunctionId function_id_
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CallRuntime(uint64_t bitfield, Runtime::FunctionId function_id, ValueNode *context)
void set_arg(int i, ValueNode *node)
void SetValueLocationConstraints()
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const Input & new_target() const
void set_arg(int i, ValueNode *node)
const Input & receiver() const
const Input & context() const
int MaxCallStackArgs() const
const Input & closure() const
CallSelf(uint64_t bitfield, int expected_parameter_count, ValueNode *closure, ValueNode *context, ValueNode *receiver, ValueNode *new_target)
int expected_parameter_count_
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
CallWithArrayLike(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void set_arg(int i, ValueNode *node)
const Input & context() const
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CallWithSpread(uint64_t bitfield, ValueNode *function, ValueNode *context)
int num_args_no_spread() const
const Input & context() const
ConvertReceiverMode receiver_mode() const
void set_arg(int i, ValueNode *node)
void SetValueLocationConstraints()
int MaxCallStackArgs() const
ConvertReceiverMode receiver_mode_
Call(uint64_t bitfield, ConvertReceiverMode mode, TargetType target_type, ValueNode *function, ValueNode *context)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
TargetType target_type() const
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
static constexpr Base::InputTypes kInputTypes
ChangeInt32ToFloat64(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
ChangeIntPtrToFloat64(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
static constexpr OpProperties kProperties
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
ChangeUint32ToFloat64(uint64_t bitfield)
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckCacheIndicesNotCleared(uint64_t bitfield)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckConstructResult(uint64_t bitfield)
Input & construct_result_input()
int MaxCallStackArgs() const
void SetValueLocationConstraints()
Input & implicit_receiver_input()
int MaxCallStackArgs() const
void SetValueLocationConstraints()
bool for_derived_constructor()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Input & construct_result_input()
CheckDerivedConstructResult(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
NextBitField< CheckType, 1 > CheckTypeBitField
CheckDetectableCallable(uint64_t bitfield, CheckType check_type)
void SetValueLocationConstraints()
void PrintParams(std::ostream &out, MaglevGraphLabeller *) const
CheckType check_type() const
CheckDynamicValue(uint64_t bitfield, DeoptimizeReason reason)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
CheckFloat64SameValue(uint64_t bitfield, Float64 value, DeoptimizeReason reason)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckHeapObject(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckHoleyFloat64IsSmi(uint64_t bitfield)
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckHoleyFloat64NotHole(uint64_t bitfield)
NextBitField< CheckType, 1 > CheckTypeBitField
InstanceType first_instance_type() const
const InstanceType last_instance_type_
CheckInstanceType(uint64_t bitfield, CheckType check_type, const InstanceType first_instance_type, const InstanceType last_instance_type)
InstanceType last_instance_type() const
CheckType check_type() const
const InstanceType first_instance_type_
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
ReasonField::Next< AssertCondition, base::bits::WhichPowerOfTwo< size_t >(base::bits::RoundUpToPowerOfTwo32(kNumAssertConditions))> ConditionField
void SetValueLocationConstraints()
CheckInt32Condition(uint64_t bitfield, AssertCondition condition, DeoptimizeReason reason)
AssertCondition condition() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
CheckInt32IsSmi(uint64_t bitfield)
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckIntPtrIsSmi(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckJSDataViewBounds(uint64_t bitfield, ExternalArrayType element_type)
ExternalArrayType element_type() const
ExternalArrayType element_type_
CheckType check_type() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
NextBitField< CheckType, 1 > CheckTypeBitField
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
CheckJSReceiverOrNullOrUndefined(uint64_t bitfield, CheckType check_type)
const compiler::ZoneRefSet< Map > maps_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckMapsWithAlreadyLoadedMap(uint64_t bitfield, base::Vector< const compiler::MapRef > maps, Zone *zone)
void SetValueLocationConstraints()
const compiler::ZoneRefSet< Map > & maps() const
CheckMapsWithAlreadyLoadedMap(uint64_t bitfield, const compiler::ZoneRefSet< Map > &maps)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckMapsWithMigrationAndDeopt(uint64_t bitfield, base::Vector< const compiler::MapRef > maps, CheckType check_type, Zone *zone)
const compiler::ZoneRefSet< Map > & maps() const
const compiler::ZoneRefSet< Map > maps_
CheckMapsWithMigrationAndDeopt(uint64_t bitfield, const compiler::ZoneRefSet< Map > &maps, CheckType check_type)
void SetValueLocationConstraints()
NextBitField< CheckType, 1 > CheckTypeBitField
CheckType check_type() const
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
CheckMapsWithMigration(uint64_t bitfield, const compiler::ZoneRefSet< Map > &maps, CheckType check_type)
const compiler::ZoneRefSet< Map > maps_
CheckType check_type() const
const compiler::ZoneRefSet< Map > & maps() const
NextBitField< CheckType, 1 > CheckTypeBitField
int MaxCallStackArgs() const
void SetValueLocationConstraints()
CheckMaps(uint64_t bitfield, base::Vector< const compiler::MapRef > maps, CheckType check_type, Zone *zone)
const compiler::ZoneRefSet< Map > maps_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
NextBitField< CheckType, 1 > CheckTypeBitField
CheckType check_type() const
const compiler::ZoneRefSet< Map > & maps() const
CheckMaps(uint64_t bitfield, const compiler::ZoneRefSet< Map > &maps, CheckType check_type)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckNotHole(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
Object::Conversion mode() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckNumber(uint64_t bitfield, Object::Conversion mode)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const Object::Conversion mode_
NextBitField< CheckType, 1 > CheckTypeBitField
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
CheckType check_type() const
CheckSeqOneByteString(uint64_t bitfield, CheckType check_type)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckSmi(uint64_t bitfield)
void SetValueLocationConstraints()
NextBitField< CheckType, 1 > CheckTypeBitField
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckType check_type() const
void SetValueLocationConstraints()
CheckStringOrOddball(uint64_t bitfield, CheckType check_type)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
NextBitField< CheckType, 1 > CheckTypeBitField
CheckType check_type() const
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckStringOrStringWrapper(uint64_t bitfield, CheckType check_type)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
NextBitField< CheckType, 1 > CheckTypeBitField
CheckType check_type() const
void SetValueLocationConstraints()
CheckString(uint64_t bitfield, CheckType check_type)
CheckSymbol(uint64_t bitfield, CheckType check_type)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckType check_type() const
NextBitField< CheckType, 1 > CheckTypeBitField
CheckTypedArrayBounds(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
CheckTypedArrayNotDetached(uint64_t bitfield)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
static constexpr Base::InputTypes kInputTypes
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckUint32IsSmi(uint64_t bitfield)
CheckValueEqualsInt32(uint64_t bitfield, int32_t value, DeoptimizeReason reason)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckValueEqualsString(uint64_t bitfield, compiler::InternalizedStringRef value, DeoptimizeReason reason)
void SetValueLocationConstraints()
const compiler::InternalizedStringRef value_
compiler::InternalizedStringRef value() const
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const compiler::HeapObjectRef value_
compiler::HeapObjectRef value() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
CheckValue(uint64_t bitfield, const compiler::HeapObjectRef value, DeoptimizeReason reason)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
int MaxCallStackArgs() const
CheckedHoleyFloat64ToFloat64(uint64_t bitfield)
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
CheckedInt32ToUint32(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckedIntPtrToInt32(uint64_t bitfield)
void SetValueLocationConstraints()
static constexpr Base::InputTypes kInputTypes
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckedIntPtrToUint32(uint64_t bitfield)
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
NextBitField< CheckType, 1 > CheckTypeBitField
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckedInternalizedString(uint64_t bitfield, CheckType check_type)
CheckType check_type() const
void SetValueLocationConstraints()
CheckedNumberOrOddballToFloat64(uint64_t bitfield, TaggedToFloat64ConversionType conversion_type)
static constexpr OpProperties kProperties
CheckedNumberOrOddballToHoleyFloat64(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
DeoptimizeReason deoptimize_reason() const
static constexpr Base::InputTypes kInputTypes
CheckedNumberToInt32(uint64_t bitfield)
static constexpr OpProperties kProperties
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
CheckedNumberToUint8Clamped(uint64_t bitfield)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CheckType check_type() const
NextBitField< CheckType, 1 > CheckTypeBitField
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
CheckedObjectToIndex(uint64_t bitfield, CheckType check_type)
CheckedSmiDecrement(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
static constexpr Base::InputTypes kInputTypes
static constexpr int kValueIndex
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr int kValueIndex
CheckedSmiIncrement(uint64_t bitfield)
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckedSmiSizedInt32(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
static constexpr Base::InputTypes kInputTypes
int MaxCallStackArgs() const
CheckedSmiTagFloat64(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckedSmiTagInt32(uint64_t bitfield)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
static constexpr Base::InputTypes kInputTypes
CheckedSmiTagIntPtr(uint64_t bitfield)
static constexpr OpProperties kProperties
static constexpr Base::InputTypes kInputTypes
CheckedSmiTagUint32(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr OpProperties kProperties
void SetValueLocationConstraints()
CheckedSmiUntag(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
CheckedTruncateFloat64ToInt32(uint64_t bitfield)
static constexpr OpProperties kProperties
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
CheckedTruncateFloat64ToUint32(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
TaggedToFloat64ConversionType conversion_type() const
NextBitField< TaggedToFloat64ConversionType, 2 > TaggedToFloat64ConversionTypeOffset
CheckedTruncateNumberOrOddballToInt32(uint64_t bitfield, TaggedToFloat64ConversionType conversion_type)
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
static constexpr OpProperties kProperties
CheckedUint32ToInt32(uint64_t bitfield)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckpointedJump(uint64_t bitfield, BasicBlockRef *target_refs)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
ConditionalControlNode(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
int MaxCallStackArgs() const
ConsStringMap(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
ConstantGapMove(uint64_t bitfield, ValueNode *node, compiler::AllocatedOperand target)
void SetValueLocationConstraints()
compiler::InstructionOperand source_
compiler::AllocatedOperand target() const
compiler::AllocatedOperand target_
bool IsTheHole(compiler::JSHeapBroker *broker) const
void DoLoadToRegister(MaglevAssembler *, OutputRegister)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
bool ToBoolean(LocalIsolate *local_isolate) const
compiler::HeapObjectRef object()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const compiler::HeapObjectRef object_
Constant(uint64_t bitfield, compiler::HeapObjectRef object)
void SetValueLocationConstraints()
compiler::HeapObjectRef ref() const
DirectHandle< Object > DoReify(LocalIsolate *isolate) const
const MaglevCompilationUnit & unit() const
ConstructInvokeStubFrameData & data()
const ConstructInvokeStubFrameData & data() const
SourcePosition source_position() const
ValueNode * receiver() const
ValueNode * context() const
ConstructInvokeStubDeoptFrame(const MaglevCompilationUnit &unit, SourcePosition source_position, ValueNode *receiver, ValueNode *context, DeoptFrame *parent)
const Input & new_target() const
int num_args_no_spread() const
compiler::FeedbackSource feedback() const
const compiler::FeedbackSource feedback_
void set_arg(int i, ValueNode *node)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
ConstructWithSpread(uint64_t bitfield, compiler::FeedbackSource feedback, ValueNode *function, ValueNode *new_target, ValueNode *context)
const Input & context() const
void SetValueLocationConstraints()
void set_arg(int i, ValueNode *node)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const Input & context() const
Construct(uint64_t bitfield, const compiler::FeedbackSource &feedback, ValueNode *function, ValueNode *new_target, ValueNode *context)
const compiler::FeedbackSource feedback_
void SetValueLocationConstraints()
int MaxCallStackArgs() const
const Input & new_target() const
compiler::FeedbackSource feedback() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void set_next_post_dominating_hole(ControlNode *node)
ControlNode * next_post_dominating_hole() const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
ConvertHoleToUndefined(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const compiler::NativeContextRef native_context_
ConvertReceiverMode mode_
compiler::NativeContextRef native_context() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
ConvertReceiver(uint64_t bitfield, compiler::NativeContextRef native_context, ConvertReceiverMode mode)
int MaxCallStackArgs() const
ConvertReceiverMode mode() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const compiler::FeedbackSource feedback_
static constexpr OpProperties kProperties
const compiler::HeapObjectRef constant_elements_
CreateArrayLiteral(uint64_t bitfield, compiler::HeapObjectRef constant_elements, const compiler::FeedbackSource &feedback, int flags)
int MaxCallStackArgs() const
compiler::HeapObjectRef constant_elements()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
compiler::FeedbackSource feedback() const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const compiler::SharedFunctionInfoRef shared_function_info_
int MaxCallStackArgs() const
CreateClosure(uint64_t bitfield, compiler::SharedFunctionInfoRef shared_function_info, compiler::FeedbackCellRef feedback_cell, bool pretenured)
const compiler::FeedbackCellRef feedback_cell_
compiler::FeedbackCellRef feedback_cell() const
compiler::SharedFunctionInfoRef shared_function_info() const
AllocationType allocation_type() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const AllocationType allocation_type_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CreateFastArrayElements(uint64_t bitfield, AllocationType allocation_type)
void SetValueLocationConstraints()
uint32_t slot_count() const
int MaxCallStackArgs() const
compiler::ScopeInfoRef scope_info() const
const compiler::ScopeInfoRef scope_info_
ScopeType scope_type() const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
CreateFunctionContext(uint64_t bitfield, compiler::ScopeInfoRef scope_info, uint32_t slot_count, ScopeType scope_type)
const uint32_t slot_count_
int MaxCallStackArgs() const
const compiler::FeedbackSource feedback_
compiler::FeedbackSource feedback() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
compiler::ObjectBoilerplateDescriptionRef boilerplate_descriptor()
CreateObjectLiteral(uint64_t bitfield, compiler::ObjectBoilerplateDescriptionRef boilerplate_descriptor, const compiler::FeedbackSource &feedback, int flags)
static constexpr OpProperties kProperties
const compiler::ObjectBoilerplateDescriptionRef boilerplate_descriptor_
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CreateRegExpLiteral(uint64_t bitfield, compiler::StringRef pattern, const compiler::FeedbackSource &feedback, int flags)
const compiler::FeedbackSource feedback_
compiler::StringRef pattern_
int MaxCallStackArgs() const
void SetValueLocationConstraints()
compiler::FeedbackSource feedback() const
compiler::StringRef pattern()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
void SetValueLocationConstraints()
CreateShallowArrayLiteral(uint64_t bitfield, compiler::HeapObjectRef constant_elements, const compiler::FeedbackSource &feedback, int flags)
compiler::FeedbackSource feedback() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const compiler::FeedbackSource feedback_
const compiler::HeapObjectRef constant_elements_
compiler::HeapObjectRef constant_elements()
int MaxCallStackArgs() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
compiler::ObjectBoilerplateDescriptionRef boilerplate_descriptor()
static constexpr OpProperties kProperties
CreateShallowObjectLiteral(uint64_t bitfield, compiler::ObjectBoilerplateDescriptionRef boilerplate_descriptor, const compiler::FeedbackSource &feedback, int flags)
const compiler::ObjectBoilerplateDescriptionRef boilerplate_descriptor_
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const compiler::FeedbackSource feedback_
compiler::FeedbackSource feedback() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
void MarkTaggedInputsAsDecompressing()
void VerifyInputs(MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
DebugBreak(uint64_t bitfield)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
int MaxCallStackArgs() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
DefineKeyedOwnGeneric(uint64_t bitfield, const compiler::FeedbackSource &feedback)
compiler::FeedbackSource feedback() const
const compiler::FeedbackSource feedback_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const compiler::FeedbackSource feedback_
int MaxCallStackArgs() const
compiler::NameRef name() const
const compiler::NameRef name_
compiler::FeedbackSource feedback() const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
DefineNamedOwnGeneric(uint64_t bitfield, compiler::NameRef name, const compiler::FeedbackSource &feedback)
LanguageMode mode() const
void SetValueLocationConstraints()
int MaxCallStackArgs() const
DeleteProperty(uint64_t bitfield, LanguageMode mode)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
SourcePosition GetSourcePosition() const
const InlinedArgumentsDeoptFrame & as_inlined_arguments() const
const ConstructInvokeStubDeoptFrame & as_construct_stub() const
VirtualObjectList GetVirtualObjects() const
compiler::SharedFunctionInfoRef GetSharedFunctionInfo() const
DeoptFrame(InterpretedFrameData &&data, DeoptFrame *parent)
const DeoptFrame * parent() const
DeoptFrame(const FrameData &data, DeoptFrame *parent)
DeoptFrame(FrameData &&data, DeoptFrame *parent)
DeoptFrame(InlinedArgumentsFrameData &&data, DeoptFrame *parent)
const InterpretedDeoptFrame & as_interpreted() const
const MaglevCompilationUnit & GetCompilationUnit() const
compiler::BytecodeArrayRef GetBytecodeArray() const
@ kConstructInvokeStubFrame
@ kBuiltinContinuationFrame
DeoptFrame(ConstructInvokeStubFrameData &&data, DeoptFrame *parent)
DeoptFrame *const parent_
const BuiltinContinuationDeoptFrame & as_builtin_continuation() const
BytecodeOffset GetBytecodeOffset() const
DeoptFrame(BuiltinContinuationFrameData &&data, DeoptFrame *parent)
InputLocation * input_locations() const
const DeoptFrame & top_frame() const
void set_translation_index(int index)
bool has_input_locations() const
InputLocation * input_locations_
void InitializeInputLocations(Zone *zone, size_t count)
const compiler::FeedbackSource & feedback_to_update() const
int translation_index() const
DeoptInfo(Zone *zone, const DeoptFrame top_frame, compiler::FeedbackSource feedback_to_update)
Label * deopt_entry_label()
const compiler::FeedbackSource feedback_to_update_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
Deopt(uint64_t bitfield, DeoptimizeReason reason)
void SetValueLocationConstraints()
EagerDeoptInfo(Zone *zone, const DeoptFrame top_frame, compiler::FeedbackSource feedback_to_update)
DeoptimizeReason reason() const
void set_reason(DeoptimizeReason reason)
void ForEachInput(Function &&f)
EnsureWritableFastElements(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
ExceptionHandlerInfo(BasicBlockRef *catch_block_ref, int depth)
BasicBlockRef catch_block_
ExceptionHandlerInfo(BasicBlock *catch_block_ref, int depth)
BasicBlock * catch_block() const
Label & trampoline_entry()
ExceptionHandlerInfo ** next()
bool ShouldLazyDeopt() const
bool HasExceptionHandler() const
BasicBlockRef * catch_block_ref_address()
ExceptionHandlerInfo * next_
void set_pc_offset(int offset)
ExceptionHandlerInfo(Mode mode=kNoExceptionHandler)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
int MaxCallStackArgs() const
Input & property_array_input()
ExtendPropertiesBackingStore(uint64_t bitfield, int old_length)
int MaxCallStackArgs() const
const compiler::SharedFunctionInfoRef shared_function_info_
FastCreateClosure(uint64_t bitfield, compiler::SharedFunctionInfoRef shared_function_info, compiler::FeedbackCellRef feedback_cell)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
compiler::SharedFunctionInfoRef shared_function_info() const
void SetValueLocationConstraints()
compiler::FeedbackCellRef feedback_cell() const
const compiler::FeedbackCellRef feedback_cell_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr OpProperties kProperties
Float64Abs(uint64_t bitfield)
static constexpr Base::InputTypes kInputTypes
static constexpr OpProperties kProperties
static constexpr int kRightIndex
static constexpr int kLeftIndex
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Float64BinaryNodeWithCall(uint64_t bitfield)
static constexpr Base::InputTypes kInputTypes
static constexpr int kRightIndex
Float64BinaryNode(uint64_t bitfield)
static constexpr OpProperties kProperties
static constexpr int kLeftIndex
static constexpr Base::InputTypes kInputTypes
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Float64Compare(uint64_t bitfield, Operation operation)
void SetValueLocationConstraints()
static constexpr int kRightIndex
void GenerateCode(MaglevAssembler *, const ProcessingState &)
constexpr Operation operation() const
static constexpr int kLeftIndex
NextBitField< Operation, 5 > OperationBitField
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
bool ToBoolean(LocalIsolate *local_isolate) const
Float64Constant(uint64_t bitfield, Float64 value)
DirectHandle< Object > DoReify(LocalIsolate *isolate) const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Float64Constant(uint64_t bitfield, uint64_t bitpattern)
void DoLoadToRegister(MaglevAssembler *, OutputRegister)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
Float64CountLeadingZeros(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static Builtin continuation()
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
DECL_ENUM(MathName, ExtName, EnumName)
ExternalReference ieee_function_ref() const
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Ieee754Function ieee_function() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
Float64Ieee754Unary(uint64_t bitfield, Ieee754Function ieee_function)
static constexpr OpProperties kProperties
Ieee754Function ieee_function_
int MaxCallStackArgs() const
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
Float64Negate(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
void SetValueLocationConstraints()
Float64Round(uint64_t bitfield, Kind kind)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
static constexpr OpProperties kProperties
static Builtin continuation(Kind kind)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
constexpr bool flip() const
NextBitField< bool, 1 > FlipBitField
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
Float64ToBoolean(uint64_t bitfield, bool flip)
static constexpr Base::InputTypes kInputTypes
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
int MaxCallStackArgs() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Float64ToHeapNumberForField(uint64_t bitfield)
static constexpr Base::InputTypes kInputTypes
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Float64ToTagged(uint64_t bitfield, ConversionMode mode)
ConversionMode conversion_mode() const
void SetValueLocationConstraints()
NextBitField< ConversionMode, 1 > ConversionModeBitField
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
static constexpr OpProperties kProperties
Float64ToUint8Clamped(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
int MaxCallStackArgs() const
compiler::FeedbackSource feedback() const
ForInNext(uint64_t bitfield, compiler::FeedbackSource &feedback)
const compiler::FeedbackSource feedback_
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr OpProperties kProperties
static constexpr Base::InputTypes kInputTypes
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
compiler::FeedbackSource feedback() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
const compiler::FeedbackSource feedback_
int MaxCallStackArgs() const
ForInPrepare(uint64_t bitfield, compiler::FeedbackSource &feedback)
FunctionEntryStackCheck(uint64_t bitfield)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
compiler::AllocatedOperand source_
compiler::AllocatedOperand target() const
compiler::AllocatedOperand target_
GapMove(uint64_t bitfield, compiler::AllocatedOperand source, compiler::AllocatedOperand target)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
compiler::AllocatedOperand source() const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
GeneratorRestoreRegister(uint64_t bitfield, int index)
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
static constexpr int kGeneratorIndex
static constexpr int kFixedInputCount
static constexpr OpProperties kProperties
Input & generator_input()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
GeneratorStore(uint64_t bitfield, ValueNode *context, ValueNode *generator, int suspend_id, int bytecode_offset)
int num_parameters_and_registers() const
void set_parameters_and_registers(int i, ValueNode *node)
void VerifyInputs(MaglevGraphLabeller *graph_labeller) const
static constexpr int kContextIndex
int MaxCallStackArgs() const
void SetValueLocationConstraints()
const int bytecode_offset_
int bytecode_offset() const
Input & parameters_and_registers(int i)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
GetContinuationPreservedEmbedderData(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
int MaxCallStackArgs() const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
void SetValueLocationConstraints()
IndirectHandle< FeedbackVector > feedback() const
GetIterator(uint64_t bitfield, int load_slot, int call_slot, compiler::FeedbackVectorRef feedback)
const IndirectHandle< FeedbackVector > feedback_
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const compiler::FeedbackSource feedback_
GetKeyedGeneric(uint64_t bitfield, const compiler::FeedbackSource &feedback)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
compiler::FeedbackSource feedback() const
GetSecondReturnedValue(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
int MaxCallStackArgs() const
compiler::SharedFunctionInfoRef shared_function_info_
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const compiler::FeedbackSource feedback_
GetTemplateObject(uint64_t bitfield, compiler::SharedFunctionInfoRef shared_function_info, const compiler::FeedbackSource &feedback)
compiler::FeedbackSource feedback() const
compiler::SharedFunctionInfoRef shared_function_info()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
HandleNoHeapWritesInterrupt(uint64_t bitfield)
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
int MaxCallStackArgs() const
compiler::HeapObjectRef prototype_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
HasInPrototypeChain(uint64_t bitfield, compiler::HeapObjectRef prototype)
compiler::HeapObjectRef prototype()
static constexpr Base::InputTypes kInputTypes
HoleyFloat64IsHole(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
int MaxCallStackArgs() const
HoleyFloat64ToMaybeNanFloat64(uint64_t bitfield)
static constexpr OpProperties kProperties
static constexpr OpProperties kProperties
ConversionMode conversion_mode() const
static constexpr Base::InputTypes kInputTypes
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void SetMode(ConversionMode mode)
NextBitField< ConversionMode, 1 > ConversionModeBitField
void GenerateCode(MaglevAssembler *, const ProcessingState &)
HoleyFloat64ToTagged(uint64_t bitfield, ConversionMode mode)
int MaxCallStackArgs() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Identity(uint64_t bitfield)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
void VerifyInputs(MaglevGraphLabeller *) const
interpreter::Register source() const
const interpreter::Register source_
static uint32_t stack_slot(uint32_t register_idx)
uint32_t stack_slot() const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
InitialValue(uint64_t bitfield, interpreter::Register source)
static constexpr OpProperties kProperties
EscapeAnalysisResult escape_analysis_result_
void VerifyInputs(MaglevGraphLabeller *graph_labeller) const
int non_escaping_use_count() const
bool HasBeenElided() const
void UpdateObject(VirtualObject *object)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
AllocationBlock * allocation_block()
InlinedAllocation ** next()
InlinedAllocation(uint64_t bitfield, VirtualObject *object)
int non_escaping_use_count_
void SetValueLocationConstraints()
void AddNonEscapingUses(int n=1)
void RemoveNonEscapingUses(int n=1)
VirtualObject * object() const
bool HasBeenAnalysed() const
static constexpr Base::InputTypes kInputTypes
void set_offset(int offset)
InlinedAllocation * next_
Input & allocation_block_input()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
ValueNode * closure() const
BytecodeOffset bytecode_position() const
InlinedArgumentsFrameData & data()
const MaglevCompilationUnit & unit() const
const InlinedArgumentsFrameData & data() const
InlinedArgumentsDeoptFrame(const MaglevCompilationUnit &unit, BytecodeOffset bytecode_position, ValueNode *closure, base::Vector< ValueNode * > arguments, DeoptFrame *parent)
base::Vector< ValueNode * > arguments() const
Int32AbsWithOverflow(uint64_t bitfield)
static constexpr int kValueIndex
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
static constexpr int kRightIndex
static constexpr int kLeftIndex
static constexpr OpProperties kProperties
Int32BinaryNode(uint64_t bitfield)
static constexpr Base::InputTypes kInputTypes
Int32BinaryWithOverflowNode(uint64_t bitfield)
static constexpr Base::InputTypes kInputTypes
static constexpr int kRightIndex
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr int kLeftIndex
static constexpr OpProperties kProperties
static constexpr Base::InputTypes kInputTypes
Int32BitwiseNot(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr int kValueIndex
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr int kLeftIndex
constexpr Operation operation() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
Int32Compare(uint64_t bitfield, Operation operation)
NextBitField< Operation, 5 > OperationBitField
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr int kRightIndex
void GenerateCode(MaglevAssembler *, const ProcessingState &)
bool ToBoolean(LocalIsolate *local_isolate) const
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
DirectHandle< Object > DoReify(LocalIsolate *isolate) const
void DoLoadToRegister(MaglevAssembler *, OutputRegister)
Int32Constant(uint64_t bitfield, int32_t value)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr OpProperties kProperties
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
Int32CountLeadingZeros(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
static constexpr OpProperties kProperties
Int32ShiftRightLogical(uint64_t bitfield)
static constexpr int kRightIndex
void SetValueLocationConstraints()
static constexpr int kLeftIndex
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
NextBitField< bool, 1 > FlipBitField
static constexpr Base::InputTypes kInputTypes
constexpr bool flip() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Int32ToBoolean(uint64_t bitfield, bool flip)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
Int32ToNumber(uint64_t bitfield)
static constexpr Base::InputTypes kInputTypes
static constexpr OpProperties kProperties
Int32ToUint8Clamped(uint64_t bitfield)
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
static constexpr Base::InputTypes kInputTypes
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr int kValueIndex
Int32UnaryWithOverflowNode(uint64_t bitfield)
static constexpr OpProperties kProperties
static constexpr Base::InputTypes kInputTypes
void DoLoadToRegister(MaglevAssembler *, OutputRegister)
DirectHandle< Object > DoReify(LocalIsolate *isolate) const
bool ToBoolean(LocalIsolate *local_isolate) const
IntPtrConstant(uint64_t bitfield, intptr_t value)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
NextBitField< bool, 1 > FlipBitField
constexpr bool flip() const
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
IntPtrToBoolean(uint64_t bitfield, bool flip)
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
IntPtrToNumber(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
static constexpr Base::InputTypes kInputTypes
int ComputeReturnOffset(interpreter::Register result_location, int result_size) const
const MaglevCompilationUnit & unit() const
InterpretedDeoptFrame(const MaglevCompilationUnit &unit, const CompactInterpreterFrameState *frame_state, ValueNode *closure, BytecodeOffset bytecode_position, SourcePosition source_position, DeoptFrame *parent)
InterpretedFrameData & data()
BytecodeOffset bytecode_position() const
const InterpretedFrameData & data() const
ValueNode * closure() const
SourcePosition source_position() const
const CompactInterpreterFrameState * frame_state() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
JumpLoop(uint64_t bitfield, BasicBlock *target)
base::Vector< Input > used_nodes()
base::Vector< Input > used_node_locations_
void set_used_nodes(base::Vector< Input > locations)
JumpLoop(uint64_t bitfield, BasicBlockRef *ref)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
Jump(uint64_t bitfield, BasicBlockRef *target_refs)
interpreter::Register result_location_
interpreter::Register result_location() const
bool HasResultLocation() const
static bool InReturnValues(interpreter::Register reg, interpreter::Register result_location, int result_size)
void set_deopting_call_return_pc(int pc)
int deopting_call_return_pc() const
static constexpr unsigned int kUninitializedCallReturnPc
void ForEachInput(Function &&f)
bool IsResultRegister(interpreter::Register reg) const
static constexpr int kMaxCodeSize
LazyDeoptInfo(Zone *zone, const DeoptFrame top_frame, interpreter::Register result_location, int result_size, compiler::FeedbackSource feedback_to_update)
const InterpretedDeoptFrame & GetFrameForExceptionHandler(const ExceptionHandlerInfo *handler_info)
LoadDoubleDataViewElement(uint64_t bitfield, ExternalArrayType type)
bool is_little_endian_constant()
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
Input & is_little_endian_input()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
LoadDoubleField(uint64_t bitfield, int offset)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
LoadEnumCacheLength(uint64_t bitfield)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
LoadFixedArrayElement(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
LoadFixedDoubleArrayElement(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
LoadFloat64(uint64_t bitfield, int offset)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const compiler::NameRef name_
const compiler::FeedbackSource feedback_
const TypeofMode typeof_mode_
int MaxCallStackArgs() const
LoadGlobal(uint64_t bitfield, compiler::NameRef name, const compiler::FeedbackSource &feedback, TypeofMode typeof_mode)
compiler::FeedbackSource feedback() const
TypeofMode typeof_mode() const
compiler::NameRef name() const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
LoadHoleyFixedDoubleArrayElementCheckedNotHole(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
LoadHoleyFixedDoubleArrayElement(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
LoadInt32(uint64_t bitfield, int offset)
compiler::NameRef name() const
compiler::FeedbackSource feedback() const
Input & lookup_start_object()
LoadNamedFromSuperGeneric(uint64_t bitfield, compiler::NameRef name, const compiler::FeedbackSource &feedback)
const compiler::NameRef name_
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
const compiler::FeedbackSource feedback_
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
compiler::NameRef name() const
const compiler::FeedbackSource feedback_
const compiler::NameRef name_
int MaxCallStackArgs() const
compiler::FeedbackSource feedback() const
LoadNamedGeneric(uint64_t bitfield, compiler::NameRef name, const compiler::FeedbackSource &feedback)
LoadSignedIntDataViewElement(uint64_t bitfield, ExternalArrayType type)
ExternalArrayType type() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Input & is_little_endian_input()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
bool is_little_endian_constant()
void SetValueLocationConstraints()
void SetValueLocationConstraints()
LoadTaggedFieldByFieldIndex(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
LoadTaggedFieldForContextSlotNoCells(uint64_t bitfield, const int offset)
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
LoadTaggedFieldForContextSlot(uint64_t bitfield, const int offset)
void SetValueLocationConstraints()
LoadTaggedFieldForProperty(uint64_t bitfield, const int offset, compiler::NameRef name)
LoadTaggedField(uint64_t bitfield, const int offset)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
ElementsKind elements_kind() const
ElementsKind elements_kind_
LoadTypedArrayLength(uint64_t bitfield, ElementsKind elements_kind)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
LogicalNot(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
static constexpr Base::InputTypes kInputTypes
compiler::SharedFunctionInfoRef shared_function_info() const
compiler::BytecodeArrayRef bytecode() const
MapPrototypeGetInt32Key(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
MapPrototypeGet(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const ElementsKind elements_kind_
void SetValueLocationConstraints()
MaybeGrowFastElements(uint64_t bitfield, ElementsKind elements_kind)
Input & elements_length_input()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
ElementsKind elements_kind() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
MigrateMapIfNeeded(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
int MaxCallStackArgs() const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void set_properties(OpProperties properties)
Address exception_handler_address() const
void set_temporaries_needed(uint8_t value)
static constexpr OpProperties kProperties
void set_owner(BasicBlock *block)
void RequireSpecificTemporary(Register reg)
void OverwriteWithIdentityTo(ValueNode *node)
constexpr uint64_t bitfield() const
void change_representation(ValueRepresentation new_repr)
InputCountField::Next< bool, 1 > ReservedField
constexpr bool Is() const
static constexpr size_t RegisterSnapshotSize(OpProperties properties)
RegList & general_temporaries()
NodeBase(const NodeBase &)=delete
const Input * last_input() const
void set_input(int index, ValueNode *node)
static constexpr int kMaxInputs
DoubleRegList & double_temporaries()
Address last_input_address() const
static constexpr Opcode opcode_of
static Derived * Allocate(Zone *zone, size_t input_count, Args &&... args)
constexpr const Input & input(int index) const
constexpr Input * input_base()
NodeBase & operator=(NodeBase &&)=delete
constexpr bool has_inputs() const
RegListBase< RegisterT > & temporaries()
OwnerOrTemporaries owner_or_temporaries_
void assign_temporaries(RegListBase< RegisterT > list)
static constexpr size_t LazyDeoptInfoSize(OpProperties properties)
constexpr const T * Cast() const
void reduce_input_count(int num=1)
static constexpr size_t EagerDeoptInfoSize(OpProperties properties)
void ForAllInputsInRegallocAssignmentOrder(Function &&f)
constexpr const Input * input_base() const
void CopyEagerDeoptInfoOf(NodeBase *other, Zone *zone)
constexpr NodeIdT id() const
void ClearUnstableNodeAspects(KnownNodeAspects &)
NodeBase(uint64_t bitfield)
void SetEagerDeoptInfo(Zone *zone, DeoptFrame deopt_frame, compiler::FeedbackSource feedback_to_update=compiler::FeedbackSource())
void change_input(int index, ValueNode *node)
static constexpr size_t ExceptionHandlerInfoSize(OpProperties properties)
Address deopt_info_address() const
Address register_snapshot_address() const
static Derived * New(Zone *zone, std::initializer_list< ValueNode * > inputs, Args &&... args)
void ClearElementsProperties(KnownNodeAspects &)
const RegisterSnapshot & register_snapshot() const
void CheckCanOverwriteWith(Opcode new_opcode, OpProperties new_properties)
void set_bitfield(uint64_t new_bitfield)
constexpr int input_count() const
constexpr Input & input(int index)
void set_opcode(Opcode new_opcode)
uint8_t num_temporaries_needed() const
constexpr const T * TryCast() const
NodeBase(NodeBase &&)=delete
void set_double_temporaries_needed(uint8_t value)
void RequireSpecificDoubleTemporary(DoubleRegister reg)
constexpr bool has_id() const
void set_register_snapshot(RegisterSnapshot snapshot)
void initialize_input_null(int index)
LazyDeoptInfo * lazy_deopt_info()
std::optional< int32_t > TryGetInt32ConstantInput(int index)
constexpr Opcode opcode() const
void OverwriteWith(Opcode new_opcode, std::optional< OpProperties > maybe_new_properties=std::nullopt)
NodeBase & operator=(const NodeBase &)=delete
EagerDeoptInfo * eager_deopt_info()
BasicBlock * owner() const
ExceptionHandlerInfo * exception_handler_info()
constexpr OpProperties properties() const
static Derived * New(Zone *zone, size_t input_count, Args &&... args)
static Derived * New(Zone *zone, std::initializer_list< ValueNode * > inputs, Args &&... args)
NodeTMixin(uint64_t bitfield, Args &&... args)
constexpr const OpProperties & properties() const
static Derived * New(Zone *zone, size_t input_count, Args &&... args)
constexpr Opcode opcode() const
static constexpr bool needs_epoch_check(Opcode op)
static constexpr bool participate_in_cse(Opcode op)
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
NumberToString(uint64_t bitfield)
static const uint32_t kPureMask
static const size_t kSize
static constexpr OpProperties TaggedValue()
constexpr bool can_allocate() const
static constexpr OpProperties ConversionNode()
constexpr bool needs_register_snapshot() const
constexpr bool is_required_when_unused() const
constexpr bool can_read() const
static constexpr OpProperties CanCallUserCode()
constexpr OpProperties(uint32_t bitfield)
static constexpr OpProperties CanThrow()
static constexpr OpProperties IntPtr()
constexpr bool can_throw() const
static constexpr OpProperties CanRead()
static constexpr OpProperties DeferredCall()
static constexpr OpProperties CanAllocate()
constexpr bool is_deopt_checkpoint() const
static constexpr OpProperties Int32()
constexpr bool can_eager_deopt() const
static constexpr OpProperties AnySideEffects()
constexpr OpProperties operator|(const OpProperties &that)
OpProperties WithNewValueRepresentation(ValueRepresentation new_repr) const
constexpr bool can_lazy_deopt() const
static constexpr OpProperties Call()
static constexpr OpProperties JSCall()
static constexpr OpProperties Uint32()
OpProperties WithoutDeopt() const
static constexpr OpProperties LazyDeopt()
static constexpr OpProperties Pure()
static constexpr OpProperties CanWrite()
constexpr bool is_any_call() const
constexpr ValueRepresentation value_representation() const
constexpr bool is_conversion() const
constexpr bool is_call() const
static constexpr OpProperties DeoptCheckpoint()
static constexpr OpProperties NeedsRegisterSnapshot()
static constexpr OpProperties Float64()
static constexpr OpProperties ForValueRepresentation(ValueRepresentation repr)
constexpr bool is_deferred_call() const
constexpr bool is_pure() const
constexpr bool is_tagged() const
static constexpr OpProperties ExternalReference()
constexpr bool not_idempotent() const
static constexpr OpProperties GenericRuntimeOrBuiltinCall()
static const uint32_t kPureValue
constexpr bool can_write() const
static constexpr OpProperties EagerDeopt()
static constexpr OpProperties NotIdempotent()
static constexpr OpProperties HoleyFloat64()
constexpr bool can_participate_in_cse() const
static constexpr OpProperties TrustedPointer()
constexpr bool can_deopt() const
UseRepresentationSet get_same_loop_uses_repr_hints()
const interpreter::Register owner_
Requires31BitValueFlag::Next< bool, 1 > LoopPhiAfterLoopFlag
void merge_type(NodeType type)
bool uses_require_31_bit_value() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const MergePointInterpreterFrameState * merge_state() const
void SetValueLocationConstraints()
NextBitField< bool, 1 > HasKeyFlag
void promote_post_loop_type()
bool is_backedge_offset(int i) const
Phi(uint64_t bitfield, MergePointInterpreterFrameState *merge_state, interpreter::Register owner)
void set_post_loop_type(NodeType type)
MergePointInterpreterFrameState *const merge_state_
NodeType post_loop_type() const
void merge_post_loop_type(NodeType type)
bool is_exception_phi() const
void set_type(NodeType type)
UseRepresentationSet get_uses_repr_hints()
void set_uses_require_31_bit_value()
interpreter::Register owner() const
void RecordUseReprHint(UseRepresentation repr)
HasKeyFlag::Next< bool, 1 > Requires31BitValueFlag
const FieldIndex field_index_
FieldIndex field_index() const
double constant_double() const
const compiler::ObjectRef constant_
static PolymorphicAccessInfo Constant(const ZoneVector< compiler::MapRef > &maps, compiler::ObjectRef constant)
const Representation representation_
static PolymorphicAccessInfo ConstantDouble(const ZoneVector< compiler::MapRef > &maps, Float64 constant)
compiler::OptionalJSObjectRef holder() const
static PolymorphicAccessInfo ModuleExport(const ZoneVector< compiler::MapRef > &maps, compiler::CellRef cell)
Representation field_representation() const
const compiler::OptionalJSObjectRef holder_
const Float64 constant_double_
PolymorphicAccessInfo(Kind kind, const ZoneVector< compiler::MapRef > &maps, Representation representation, compiler::ObjectRef constant)
static PolymorphicAccessInfo StringLength(const ZoneVector< compiler::MapRef > &maps)
PolymorphicAccessInfo(Kind kind, const ZoneVector< compiler::MapRef > &maps, Representation representation)
DirectHandle< Cell > cell() const
struct v8::internal::maglev::PolymorphicAccessInfo::@103::@105 data_load_
static PolymorphicAccessInfo NotFound(const ZoneVector< compiler::MapRef > &maps)
DirectHandle< Object > constant() const
const ZoneVector< compiler::MapRef > maps_
PolymorphicAccessInfo(Kind kind, const ZoneVector< compiler::MapRef > &maps, Float64 constant)
size_t hash_value() const
const ZoneVector< compiler::MapRef > & maps() const
bool operator==(const PolymorphicAccessInfo &other) const
PolymorphicAccessInfo(Kind kind, const ZoneVector< compiler::MapRef > &maps, Representation representation, compiler::OptionalJSObjectRef holder, FieldIndex field_index)
static PolymorphicAccessInfo DataLoad(const ZoneVector< compiler::MapRef > &maps, Representation representation, compiler::OptionalJSObjectRef holder, FieldIndex field_index)
ReduceInterruptBudgetForLoop(uint64_t bitfield, int amount)
ReduceInterruptBudgetForReturn(uint64_t bitfield, int amount)
RestLength(uint64_t bitfield, int formal_parameter_count)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
int formal_parameter_count() const
int formal_parameter_count_
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Return(uint64_t bitfield)
void SetValueLocationConstraints()
RootConstant(uint64_t bitfield, RootIndex index)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
bool ToBoolean(LocalIsolate *local_isolate) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
Handle< Object > DoReify(LocalIsolate *isolate) const
void DoLoadToRegister(MaglevAssembler *, OutputRegister)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
SeqOneByteStringAt(uint64_t bitfield)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
SetContinuationPreservedEmbedderData(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const compiler::FeedbackSource feedback_
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
int MaxCallStackArgs() const
SetKeyedGeneric(uint64_t bitfield, const compiler::FeedbackSource &feedback)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
compiler::FeedbackSource feedback() const
const compiler::FeedbackSource feedback_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const compiler::NameRef name_
void SetValueLocationConstraints()
int MaxCallStackArgs() const
compiler::FeedbackSource feedback() const
SetNamedGeneric(uint64_t bitfield, compiler::NameRef name, const compiler::FeedbackSource &feedback)
compiler::NameRef name() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
SetPendingMessage(uint64_t bitfield)
static constexpr OpProperties kProperties
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
SetPrototypeHas(uint64_t bitfield)
Tagged< Smi > value() const
void DoLoadToRegister(MaglevAssembler *, OutputRegister)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
bool ToBoolean(LocalIsolate *local_isolate) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
SmiConstant(uint64_t bitfield, int32_t value)
const Tagged< Smi > value_
DirectHandle< Object > DoReify(LocalIsolate *isolate) const
SmiCountLeadingZeros(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
static constexpr OpProperties kProperties
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
StoreContextSlotWithWriteBarrier(uint64_t bitfield, int index)
Input & new_value_input()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
int MaxCallStackArgs() const
StoreDoubleDataViewElement(uint64_t bitfield, ExternalArrayType type)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
bool is_little_endian_constant()
void SetValueLocationConstraints()
Input & is_little_endian_input()
StoreDoubleField(uint64_t bitfield, int offset)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
StoreFixedArrayElementNoWriteBarrier(uint64_t bitfield)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
int MaxCallStackArgs() const
StoreFixedArrayElementWithWriteBarrier(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
StoreFixedDoubleArrayElement(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
StoreFloat64(uint64_t bitfield, int offset)
void SetValueLocationConstraints()
StoreGlobal(uint64_t bitfield, compiler::NameRef name, const compiler::FeedbackSource &feedback)
const compiler::NameRef name_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
compiler::FeedbackSource feedback() const
void SetValueLocationConstraints()
int MaxCallStackArgs() const
compiler::NameRef name() const
const compiler::FeedbackSource feedback_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
int MaxCallStackArgs() const
const compiler::FeedbackSource feedback_
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
StoreInArrayLiteralGeneric(uint64_t bitfield, const compiler::FeedbackSource &feedback)
compiler::FeedbackSource feedback() const
void SetValueLocationConstraints()
StoreInt32(uint64_t bitfield, int offset)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const compiler::MapRef map_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
NextBitField< Kind, 3 > KindField
StoreMap(uint64_t bitfield, compiler::MapRef map, Kind kind)
compiler::MapRef map() const
int MaxCallStackArgs() const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
ExternalArrayType type() const
void SetValueLocationConstraints()
StoreSignedIntDataViewElement(uint64_t bitfield, ExternalArrayType type)
bool is_little_endian_constant()
Input & is_little_endian_input()
bool initializing_or_transitioning() const
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
StoreTaggedFieldNoWriteBarrier(uint64_t bitfield, int offset, StoreTaggedMode store_mode)
void SetValueLocationConstraints()
NextBitField< bool, 1 > InitializingOrTransitioningField
bool initializing_or_transitioning() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
NextBitField< bool, 1 > InitializingOrTransitioningField
void SetValueLocationConstraints()
StoreTaggedFieldWithWriteBarrier(uint64_t bitfield, int offset, StoreTaggedMode store_mode)
int MaxCallStackArgs() const
NextBitField< bool, 1 > InitializingOrTransitioningField
IndirectPointerTag tag() const
bool initializing_or_transitioning() const
const IndirectPointerTag tag_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
StoreTrustedPointerFieldWithWriteBarrier(uint64_t bitfield, int offset, IndirectPointerTag tag, StoreTaggedMode store_mode)
int MaxCallStackArgs() const
void SetValueLocationConstraints()
int MaxCallStackArgs() const
void SetValueLocationConstraints()
StringAt(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
StringConcat(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
int MaxCallStackArgs() const
int MaxCallStackArgs() const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
StringEqualInputs inputs() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
StringEqual(uint64_t bitfield, StringEqualInputs inputs)
void SetValueLocationConstraints()
StringEqualInputs inputs_
void SetValueLocationConstraints()
StringLength(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void set_fallthrough(BasicBlock *fallthrough)
bool has_fallthrough() const
Switch(uint64_t bitfield, int value_base, BasicBlockRef *targets, int size, BasicBlockRef *fallthrough)
Switch(uint64_t bitfield, int value_base, BasicBlockRef *targets, int size)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
BasicBlock * fallthrough() const
void SetValueLocationConstraints()
std::optional< BasicBlockRef > fallthrough_
BasicBlockRef * targets() const
TaggedEqual(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
bool ToBoolean(LocalIsolate *local_isolate) const
DirectHandle< Object > DoReify(LocalIsolate *isolate) const
void DoLoadToRegister(MaglevAssembler *, OutputRegister)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
TaggedIndexConstant(uint64_t bitfield, int value)
void SetValueLocationConstraints()
Tagged< TaggedIndex > value() const
const Tagged< TaggedIndex > value_
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
TaggedNotEqual(uint64_t bitfield)
TerminalControlNodeT(uint64_t bitfield)
TerminalControlNode(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
const compiler::FeedbackSource & feedback() const
const compiler::FeedbackSource feedback_
TestInstanceOf(uint64_t bitfield, const compiler::FeedbackSource &feedback)
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
interpreter::TestTypeOfFlags::LiteralFlag literal_
void SetValueLocationConstraints()
TestTypeOf(uint64_t bitfield, interpreter::TestTypeOfFlags::LiteralFlag literal)
interpreter::TestTypeOfFlags::LiteralFlag literal() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
CheckType check_type() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
TestUndetectable(uint64_t bitfield, CheckType check_type)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
NextBitField< CheckType, 1 > CheckTypeBitField
int MaxCallStackArgs() const
ThrowIfNotCallable(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
void SetValueLocationConstraints()
ThrowIfNotSuperConstructor(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
compiler::NameRef name() const
int MaxCallStackArgs() const
ThrowReferenceErrorIfHole(uint64_t bitfield, const compiler::NameRef name)
void SetValueLocationConstraints()
const compiler::NameRef name_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
int MaxCallStackArgs() const
ThrowSuperAlreadyCalledIfNotHole(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
ThrowSuperNotCalledIfHole(uint64_t bitfield)
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
ToBooleanLogicalNot(uint64_t bitfield, CheckType check_type)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckType check_type() const
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
NextBitField< CheckType, 1 > CheckTypeBitField
NextBitField< CheckType, 1 > CheckTypeBitField
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
CheckType check_type() const
ToBoolean(uint64_t bitfield, CheckType check_type)
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
ToName(uint64_t bitfield)
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
ToNumberOrNumeric(uint64_t bitfield, Object::Conversion mode)
Object::Conversion mode() const
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
int MaxCallStackArgs() const
const Object::Conversion mode_
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
CheckType check_type() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
NextBitField< CheckType, 1 > CheckTypeBitField
int MaxCallStackArgs() const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
ToObject(uint64_t bitfield, CheckType check_type)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
int MaxCallStackArgs() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
NextBitField< ConversionMode, 1 > ConversionModeBitField
ConversionMode mode() const
static constexpr OpProperties kProperties
ToString(uint64_t bitfield, ConversionMode mode)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
TransitionAndStoreArrayElement(uint64_t bitfield, const compiler::MapRef &fast_map, const compiler::MapRef &double_map)
const compiler::MapRef double_map_
const compiler::MapRef fast_map_
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
compiler::MapRef fast_map() const
int MaxCallStackArgs() const
compiler::MapRef double_map() const
void SetValueLocationConstraints()
int MaxCallStackArgs() const
ZoneVector< compiler::MapRef > transition_sources_
const compiler::MapRef transition_target() const
TransitionElementsKindOrCheckMap(uint64_t bitfield, const ZoneVector< compiler::MapRef > &transition_sources, compiler::MapRef transition_target)
const ZoneVector< compiler::MapRef > & transition_sources() const
const compiler::MapRef transition_target_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const ZoneVector< compiler::MapRef > & transition_sources() const
const compiler::MapRef transition_target() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
int MaxCallStackArgs() const
TransitionElementsKind(uint64_t bitfield, const ZoneVector< compiler::MapRef > &transition_sources, compiler::MapRef transition_target)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
ZoneVector< compiler::MapRef > transition_sources_
const compiler::MapRef transition_target_
void GenerateCode(MaglevAssembler *, const ProcessingState &)
TaggedToFloat64ConversionType conversion_type() const
NextBitField< TaggedToFloat64ConversionType, 2 > TaggedToFloat64ConversionTypeOffset
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr OpProperties kProperties
void SetValueLocationConstraints()
TruncateNumberOrOddballToInt32(uint64_t bitfield, TaggedToFloat64ConversionType conversion_type)
static constexpr Base::InputTypes kInputTypes
IndirectPointerTag tag() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
bool ToBoolean(LocalIsolate *local_isolate) const
static constexpr OpProperties kProperties
void DoLoadToRegister(MaglevAssembler *, OutputRegister)
TrustedConstant(uint64_t bitfield, compiler::HeapObjectRef object, IndirectPointerTag tag)
DirectHandle< Object > DoReify(LocalIsolate *isolate) const
void GenerateCode(MaglevAssembler *, const ProcessingState &)
const IndirectPointerTag tag_
const compiler::HeapObjectRef object_
compiler::HeapObjectRef object() const
void SetValueLocationConstraints()
int MaxCallStackArgs() const
TryOnStackReplacement(uint64_t bitfield, int32_t loop_depth, FeedbackSlot feedback_slot, BytecodeOffset osr_offset, MaglevCompilationUnit *unit)
static constexpr OpProperties kProperties
MaglevCompilationUnit *const unit_
const MaglevCompilationUnit * unit() const
const BytecodeOffset osr_offset_
const int32_t loop_depth_
static constexpr Base::InputTypes kInputTypes
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
const FeedbackSlot feedback_slot_
void DoLoadToRegister(MaglevAssembler *, OutputRegister)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
Uint32Constant(uint64_t bitfield, uint32_t value)
void SetValueLocationConstraints()
bool ToBoolean(LocalIsolate *local_isolate) const
DirectHandle< Object > DoReify(LocalIsolate *isolate) const
static constexpr OpProperties kProperties
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr Base::InputTypes kInputTypes
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr OpProperties kProperties
Uint32ToNumber(uint64_t bitfield)
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
Uint32ToUint8Clamped(uint64_t bitfield)
void SetValueLocationConstraints()
UnaryWithFeedbackNode(uint64_t bitfield, const compiler::FeedbackSource &feedback)
static constexpr int kOperandIndex
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
compiler::FeedbackSource feedback() const
static constexpr OpProperties kProperties
const compiler::FeedbackSource feedback_
void SetValueLocationConstraints()
UncheckedNumberOrOddballToFloat64(uint64_t bitfield, TaggedToFloat64ConversionType conversion_type)
static constexpr OpProperties kProperties
NextBitField< TaggedToFloat64ConversionType, 2 > TaggedToFloat64ConversionTypeOffset
void SetValueLocationConstraints()
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
TaggedToFloat64ConversionType conversion_type() const
UnconditionalControlNodeT(uint64_t bitfield, BasicBlockRef *target_refs)
UnconditionalControlNodeT(uint64_t bitfield, BasicBlock *target)
void set_predecessor_id(int id)
int predecessor_id() const
UnconditionalControlNode(uint64_t bitfield, BasicBlock *target)
UnconditionalControlNode(uint64_t bitfield, BasicBlockRef *target_refs)
void set_target(BasicBlock *block)
BasicBlock * target() const
static constexpr OpProperties kProperties
UnsafeInt32ToUint32(uint64_t bitfield)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void SetValueLocationConstraints()
UnsafeSmiTagInt32(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
UnsafeSmiTagIntPtr(uint64_t bitfield)
static constexpr Base::InputTypes kInputTypes
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
static constexpr OpProperties kProperties
void SetValueLocationConstraints()
UnsafeSmiTagUint32(uint64_t bitfield)
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
static constexpr OpProperties kProperties
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
void GenerateCode(MaglevAssembler *, const ProcessingState &)
UnsafeSmiUntag(uint64_t bitfield)
static constexpr Base::InputTypes kInputTypes
void GenerateCode(MaglevAssembler *, const ProcessingState &)
int MaxCallStackArgs() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
UnwrapStringWrapper(uint64_t bitfield)
void SetValueLocationConstraints()
UpdateJSArrayLength(uint64_t bitfield)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
void SetValueLocationConstraints()
compiler::InstructionOperand operand_
Register AssignedGeneralRegister() const
bool IsDoubleRegister() const
bool IsGeneralRegister() const
const compiler::InstructionOperand & operand() const
bool IsAnyRegister() const
void SetUnallocated(Args &&... args)
void InjectLocation(compiler::InstructionOperand location)
void SetConstant(Args &&... args)
const compiler::InstructionOperand & operand()
void SetAllocated(Args &&... args)
DoubleRegister AssignedDoubleRegister() const
compiler::InstructionOperand hint_
const ValueLocation & result() const
bool unused_inputs_were_visited() const
void record_next_use(NodeIdT id, InputLocation *input_location)
compiler::InstructionOperand loadable_slot() const
constexpr ValueRepresentation value_representation() const
bool has_register() const
LiveRange live_range() const
void AddRegister(DoubleRegister reg)
int FirstRegisterCode() const
NodeIdT current_next_use() const
compiler::AllocatedOperand spill_slot() const
void LoadToRegister(MaglevAssembler *, DoubleRegister)
RegList registers_with_result_
constexpr bool is_tagged() const
ValueNode(uint64_t bitfield)
bool has_valid_live_range() const
bool StaticTypeIs(compiler::JSHeapBroker *broker, NodeType type)
void advance_next_use(NodeIdT use)
void AddRegister(Register reg)
void Spill(compiler::AllocatedOperand operand)
DirectHandle< Object > Reify(LocalIsolate *isolate) const
compiler::OptionalHeapObjectRef TryGetConstant(compiler::JSHeapBroker *broker)
bool has_no_more_uses() const
void LoadToRegister(MaglevAssembler *, Register)
void InitializeRegisterData()
RegListBase< T > result_registers()
int num_registers() const
compiler::InstructionOperand spill_
RegListBase< T > ClearRegisters()
constexpr bool decompresses_tagged_result() const
NodeIdT * last_uses_next_use_id_
void RemoveRegister(Register reg)
void DoLoadToRegister(MaglevAssembler *, Register)
compiler::InstructionOperand allocation() const
void mark_unused_inputs_visited()
RegisterT GetRegisterHint()
void SetConstantLocation()
void SetHint(compiler::InstructionOperand hint)
NodeType GetStaticType(compiler::JSHeapBroker *broker)
constexpr bool use_double_register() const
constexpr MachineRepresentation GetMachineRepresentation() const
bool is_in_register(DoubleRegister reg) const
void DoLoadToRegister(MaglevAssembler *, DoubleRegister)
const compiler::InstructionOperand & hint() const
DoubleRegList double_registers_with_result_
bool is_in_register(Register reg) const
void RemoveRegister(DoubleRegister reg)
bool operator==(const Iterator &other) const
VirtualObject *& operator*()
VirtualObject * operator->()
Iterator(VirtualObject *entry)
bool operator!=(const Iterator &other) const
void Add(VirtualObject *object)
void Print(std::ostream &os, const char *prefix, MaglevGraphLabeller *labeller) const
VirtualObject * FindAllocatedWith(const InlinedAllocation *allocation) const
static VirtualObject * WalkUntilCommon(const VirtualObjectList &list1, const VirtualObjectList &list2, Function &&f)
bool operator==(const VirtualObjectList &other) const
void ForEachNestedRuntimeInput(VirtualObjectList virtual_objects, Function &&f)
constexpr bool has_static_map() const
void set(uint32_t offset, ValueNode *value)
ValueNode * string_length() const
void ForEachInput(Function &&callback)
compiler::FixedDoubleArrayRef double_elements() const
VirtualObject(uint64_t bitfield, compiler::MapRef map, int id, uint32_t length, compiler::FixedDoubleArrayRef elements)
void GenerateCode(MaglevAssembler *, const ProcessingState &)
void ClearSlots(int last_init_slot, ValueNode *clear_value)
void SetValueLocationConstraints()
VirtualObject(uint64_t bitfield, compiler::MapRef map, int id, Float64 number)
void set_allocation(InlinedAllocation *allocation)
void ForEachInput(Function &&callback) const
ValueNode * get(uint32_t offset) const
std::optional< VirtualObject * > Merge(const VirtualObject *other, uint32_t new_object_id, Zone *zone, Function MergeValue) const
uint32_t double_elements_length() const
const VirtualConsString & cons_string() const
VirtualObject(uint64_t bitfield, compiler::MapRef map, int id, uint32_t slot_count, ValueNode **slots)
uint32_t slot_count() const
compiler::OptionalMapRef map_
ValueNode * get_by_index(uint32_t i) const
InlinedAllocation * allocation() const
DoubleArray double_array_
compiler::MapRef map() const
void PrintParams(std::ostream &, MaglevGraphLabeller *) const
VirtualConsString cons_string_
VirtualObject(uint64_t bitfield, int id, const VirtualConsString &cons_string)
void set_by_index(uint32_t i, ValueNode *value)
bool compatible_for_merge(const VirtualObject *other) const
friend std::ostream & operator<<(std::ostream &out, Type type)
InlinedAllocation * allocation_
VirtualObject * Clone(uint32_t new_object_id, Zone *zone, bool empty_clone=false) const
constexpr ArrayWrapper(Args &&... args)
other heap size generate builtins concurrently on separate threads in mksnapshot track concurrent recompilation artificial compilation delay in ms max number of threads that concurrent Turbofan can create additional concurrent optimization jobs but throw away result whether maglev resets the interrupt budget whether maglev resets the OSR interrupt budget create additional concurrent optimization jobs maximum levels for nesting child serializers trace the heap broker(reports on missing data only)") DEFINE_INT(deopt_every_n_times
other heap size generate builtins concurrently on separate threads in mksnapshot track concurrent recompilation artificial compilation delay in ms max number of threads that concurrent Turbofan can use(0 for unbounded)") DEFINE_BOOL( stress_concurrent_inlining
too high values may cause the compiler to set high thresholds for inlining to as much as possible avoid inlined allocation of objects that cannot escape trace load stores from virtual maglev objects use TurboFan fast string builder analyze liveness of environment slots and zap dead values trace TurboFan load elimination emit data about basic block usage in builtins to this enable builtin reordering when run mksnapshot flag for emit warnings when applying builtin profile data verify register allocation in TurboFan randomly schedule instructions to stress dependency tracking enable store store elimination in TurboFan rewrite far to near simulate GC compiler thread race related to allow float parameters to be passed in simulator mode JS Wasm Run additional turbo_optimize_inlined_js_wasm_wrappers enables Turboshaft s StaticAssert and CheckTurboshaftTypeOf operations Wasm code into JS functions via the JS to Wasm wrappers are still inlined in TurboFan For controlling whether to at see turbo inline js wasm calls enable Turboshaft s loop unrolling enable an additional Turboshaft phase that performs optimizations based on type information enable Turbolev features that we want to ship in the not too far future trace individual Turboshaft reduction steps trace intermediate Turboshaft reduction steps trace Turboshaft s if else to switch reducer invocation count threshold for early optimization Enables optimizations which favor memory size over execution speed Enables sampling allocation profiler with X as a sample interval min size of a semi the new space consists of two semi spaces max size of the preconfigured old space Collect garbage after Collect garbage after keeps maps alive for< n > old space garbage collections print one detailed trace line in name
too high values may cause the compiler to set high thresholds for inlining to as much as possible avoid inlined allocation of objects that cannot escape trace load stores from virtual maglev objects use TurboFan fast string builder analyze liveness of environment slots and zap dead values trace TurboFan load elimination emit data about basic block usage in builtins to this enable builtin reordering when run mksnapshot flag for emit warnings when applying builtin profile data verify register allocation in TurboFan randomly schedule instructions to stress dependency tracking enable store store elimination in TurboFan rewrite far to near simulate GC compiler thread race related to allow float parameters to be passed in simulator mode JS Wasm Run additional turbo_optimize_inlined_js_wasm_wrappers enables Turboshaft s StaticAssert and CheckTurboshaftTypeOf operations Wasm code into JS functions via the JS to Wasm wrappers are still inlined in TurboFan For controlling whether to at see turbo inline js wasm calls enable Turboshaft s loop unrolling enable an additional Turboshaft phase that performs optimizations based on type information enable Turbolev features that we want to ship in the not too far future trace individual Turboshaft reduction steps trace intermediate Turboshaft reduction steps trace Turboshaft s if else to switch reducer invocation count threshold for early optimization Enables optimizations which favor memory size over execution speed Enables sampling allocation profiler with X as a sample interval min size of a semi the new space consists of two semi spaces max size of the preconfigured old space size(in Mbytes)") DEFINE_INT(random_gc_interval
refactor address components for immediate indexing make OptimizeMaglevOnNextCall optimize to turbofan instead of maglev filter for tracing turbofan compilation nullptr
too high values may cause the compiler to set high thresholds for inlining to as much as possible avoid inlined allocation of objects that cannot escape trace load stores from virtual maglev objects use TurboFan fast string builder analyze liveness of environment slots and zap dead values trace TurboFan load elimination emit data about basic block usage in builtins to this enable builtin reordering when run mksnapshot flag for emit warnings when applying builtin profile data verify register allocation in TurboFan randomly schedule instructions to stress dependency tracking enable store store elimination in TurboFan rewrite far to near simulate GC compiler thread race related to allow float parameters to be passed in simulator mode JS Wasm Run additional turbo_optimize_inlined_js_wasm_wrappers enables Turboshaft s StaticAssert and CheckTurboshaftTypeOf operations Wasm code into JS functions via the JS to Wasm wrappers are still inlined in TurboFan For controlling whether to at see turbo inline js wasm calls enable Turboshaft s loop unrolling enable an additional Turboshaft phase that performs optimizations based on type information enable Turbolev features that we want to ship in the not too far future trace individual Turboshaft reduction steps trace intermediate Turboshaft reduction steps trace Turboshaft s if else to switch reducer invocation count threshold for early optimization Enables optimizations which favor memory size over execution speed Enables sampling allocation profiler with X as a sample interval min size of a semi the new space consists of two semi spaces max size of the preconfigured old space Collect garbage after Collect garbage after keeps maps alive for< n > old space garbage collections print one detailed trace line in allocation gc speed threshold for starting incremental marking via a task in percent of available threshold for starting incremental marking immediately in percent of available Use a single schedule for determining a marking schedule between JS and C objects schedules the minor GC task with kUserVisible priority max worker number of concurrent for NumberOfWorkerThreads start background threads that allocate memory concurrent_array_buffer_sweeping use parallel threads to clear weak refs in the atomic pause trace progress of the incremental marking trace object counts and memory usage report a tick only when allocated zone memory changes by this amount TracingFlags::gc_stats TracingFlags::gc_stats track native contexts that are expected to be garbage collected verify heap pointers before and after GC memory reducer runs GC with ReduceMemoryFootprint flag Maximum number of memory reducer GCs scheduled Old gen GC speed is computed directly from gc tracer counters Perform compaction on full GCs based on V8 s default heuristics Perform compaction on every full GC Perform code space compaction when finalizing a full GC with stack Stress GC compaction to flush out bugs with moving objects flush of baseline code when it has not been executed recently Use time base code flushing instead of age Use a progress bar to scan large objects in increments when incremental marking is active force incremental marking for small heaps and run it more often Release pooled large pages after X seconds prints number of allocations and enables analysis mode for gc fuzz e g stress stress scavenge force scavenge at random points between and reclaim otherwise unreachable unmodified wrapper objects when possible discard the memory pool before invoking the GC on memory pressure or last resort GCs Delay before memory reducer start virtual randomize memory reservations by ignoring any hints passed when allocating pages use incremental marking for CppHeap cppheap_concurrent_marking c value for membalancer A special constant to balance between memory and space tradeoff The smaller the more memory it uses enable use of SSE4 instructions if available enable use of SAHF instruction if enable use of AVX VNNI instructions if available enable use of POPCNT instruction if available force all emitted branches to be in long mode(MIPS/PPC only)") DEFINE_BOOL(partial_constant_pool
other heap size flags(e.g. initial_heap_size) take precedence") DEFINE_SIZE_T( max_shared_heap_size
#define DEF_OPCODE_OF(Name)
#define DEF_FORWARD_DECLARATION(type,...)
#define CONDITIONAL_CONTROL_NODE_LIST(V)
#define DEOPTIMIZE_REASON_FIELD
#define DEF_INT32_UNARY_WITH_OVERFLOW_NODE(Name)
#define NODE_BASE_LIST(V)
#define NODE_TYPE_LIST(V)
#define STORE_TYPED_ARRAY(name, properties, type,...)
#define DEF_BINARY_WITH_FEEDBACK_NODE(Name)
#define LEAF_NODE_TYPE_LIST(V)
#define LOAD_TYPED_ARRAY(name, properties,...)
#define ADD_STATIC_ASSERT(Name, Value)
#define GAP_MOVE_NODE_LIST(V)
#define DEF_UNARY_WITH_FEEDBACK_NODE(Name)
#define STORE_CONSTANT_TYPED_ARRAY(name, properties, type,...)
#define BRANCH_CONTROL_NODE_LIST(V)
#define VALUE_NODE_LIST(V)
#define CONTROL_NODE_LIST(V)
#define UNCONDITIONAL_CONTROL_NODE_LIST(V)
#define DEF_FLOAT64_BINARY_NODE_WITH_CALL(Name)
#define IEEE_754_UNARY_LIST(V)
#define DEF_OPCODES(type)
#define DEFINE_NODE_TYPE_CHECK(Type, _)
#define DEF_FLOAT64_BINARY_NODE(Name)
#define DEF_INT32_BINARY_WITH_OVERFLOW_NODE(Name)
#define TERMINAL_CONTROL_NODE_LIST(V)
#define LOAD_CONSTANT_TYPED_ARRAY(name, properties,...)
#define ASSERT_CONDITION(V)
#define DEF_INT32_BINARY_NODE(Name)
#define CONSTANT_VALUE_NODE_LIST(V)
constexpr unsigned CountTrailingZerosNonZero(T value) requires(std
constexpr int ClearLsb(T value) requires std
auto make_iterator_range(ForwardIterator begin, ForwardIterator end)
size_t hash_value(unsigned long v)
size_t hash_combine(size_t seed, size_t hash)
V8_BASE_EXPORT int const char va_list args
void Add(RWDigits Z, Digits X, Digits Y)
void Subtract(RWDigits Z, Digits X, Digits Y)
Maybe< int > OffsetOfElementAt(ElementAccess const &access, int index)
bool CanAllocate(const Node *node)
constexpr size_t input_count()
FloatWithBits< 64 > Float64
Node::Uses::const_iterator end(const Node::Uses &uses)
Node::Uses::const_iterator begin(const Node::Uses &uses)
constexpr T * ObjectPtrBeforeAddress(void *address)
UINT32_ELEMENTS INT32_ELEMENTS FLOAT32_ELEMENTS
static constexpr NodeIdT kInvalidNodeId
constexpr bool IsControlNode(Opcode opcode)
std::underlying_type_t< NodeType > NodeTypeInt
static constexpr Opcode kLastNodeOpcode
constexpr Condition ConditionForNaN()
static constexpr Opcode kLastOpcode
NodeType StaticTypeForConstant(compiler::JSHeapBroker *broker, compiler::ObjectRef ref)
static constexpr Opcode kLastGapMoveNodeOpcode
requires(FloatType==ValueRepresentation::kFloat64||FloatType==ValueRepresentation::kHoleyFloat64) void CheckedNumberOrOddballToFloat64OrHoleyFloat64< Derived
static constexpr Opcode kFirstUnconditionalControlNodeOpcode
bool HasOnlyStringMaps(base::Vector< const compiler::MapRef > maps)
base::EnumSet< UseRepresentation, int8_t > UseRepresentationSet
static constexpr int kOpcodeCount
base::EnumSet< ValueRepresentation, int8_t > ValueRepresentationSet
static constexpr Opcode kLastControlNodeOpcode
bool IsInstanceOfLeafNodeType(compiler::MapRef map, NodeType type, compiler::JSHeapBroker *broker)
constexpr Condition ConditionFor(Operation operation)
static constexpr Opcode kFirstNodeOpcode
constexpr NodeType EmptyNodeType()
constexpr bool IsTerminalControlNode(Opcode opcode)
constexpr NodeType UnionType(NodeType left, NodeType right)
FixedInputNodeTMixin< InputCount, ValueNodeT< Derived >, Derived > FixedInputValueNodeT
UINT32_ELEMENTS INT8_ELEMENTS
bool HasOnlyNumberMaps(base::Vector< const compiler::MapRef > maps)
constexpr bool NodeTypeIs(NodeType type, NodeType to_check)
constexpr bool IsZeroCostNode(Opcode opcode)
constexpr bool IsEmptyNodeType(NodeType type)
static constexpr Opcode kLastConstantNodeOpcode
bool HasOnlyJSTypedArrayMaps(base::Vector< const compiler::MapRef > maps)
static constexpr Opcode kFirstGapMoveNodeOpcode
constexpr OpProperties StaticPropertiesForOpcode(Opcode opcode)
static constexpr Opcode kLastTerminalControlNodeOpcode
constexpr NodeType IntersectType(NodeType left, NodeType right)
constexpr bool NodeTypeIsUnstable(NodeType type)
const char * OpcodeToString(Opcode opcode)
bool IsInitializingOrTransitioning(StoreTaggedMode mode)
constexpr NodeType MakeTypeStable(NodeType type)
constexpr bool IsConstantNode(Opcode opcode)
static constexpr Opcode kLastConditionalControlNodeOpcode
static constexpr NodeIdT kFirstValidNodeId
UINT32_ELEMENTS INT16_ELEMENTS
void CheckValueInputIs(const NodeBase *node, int i, ValueRepresentation expected, MaglevGraphLabeller *graph_labeller)
constexpr bool IsZeroExtendedRepresentation(ValueRepresentation repr)
constexpr bool IsValueNode(Opcode opcode)
DEFINE_TRUNCATE_NODE(TruncateFloat64ToInt32, HoleyFloat64, OpProperties::Int32()) DEFINE_TRUNCATE_NODE(UnsafeTruncateFloat64ToInt32
static constexpr int kNumAssertConditions
static constexpr Opcode kLastBranchControlNodeOpcode
static constexpr Opcode kLastValueNodeOpcode
constexpr bool IsCommutativeNode(Opcode opcode)
static constexpr Opcode kFirstValueNodeOpcode
bool IsInstanceOfNodeType(compiler::MapRef map, NodeType type, compiler::JSHeapBroker *broker)
bool FromConstantToBool(LocalIsolate *local_isolate, ValueNode *node)
static constexpr Opcode kFirstControlNodeOpcode
constexpr bool IsConditionalControlNode(Opcode opcode)
std::ostream & operator<<(std::ostream &os, const PrintNode &printer)
DEFINE_NODE_TYPE(Name, Value)
constexpr bool IsDoubleRepresentation(ValueRepresentation repr)
constexpr bool IsSimpleFieldStore(Opcode opcode)
NodeType StaticTypeForMap(compiler::MapRef map, compiler::JSHeapBroker *broker)
constexpr bool CanBeStoreToNonEscapedObject(Opcode opcode)
constexpr bool IsTypedArrayStore(Opcode opcode)
TaggedToFloat64ConversionType
static constexpr Opcode kFirstConstantNodeOpcode
constexpr bool NodeTypeIsNeverStandalone(NodeType type)
bool HasNumberMap(base::Vector< const compiler::MapRef > maps)
static constexpr Opcode kFirstOpcode
static constexpr int kNumberOfLeafNodeTypes
bool NodeTypeMayBeNullOrUndefined(NodeType type)
static constexpr Opcode kLastUnconditionalControlNodeOpcode
constexpr bool IsBranchControlNode(Opcode opcode)
bool HasOnlyJSArrayMaps(base::Vector< const compiler::MapRef > maps)
static constexpr Opcode kFirstTerminalControlNodeOpcode
static constexpr Opcode kFirstBranchControlNodeOpcode
constexpr bool NodeTypeCanBe(NodeType type, NodeType to_check)
constexpr bool IsUnconditionalControlNode(Opcode opcode)
constexpr bool IsGapMoveNode(Opcode opcode)
bool HasOnlyJSObjectMaps(base::Vector< const compiler::MapRef > maps)
static constexpr Opcode kFirstConditionalControlNodeOpcode
constexpr bool IsElementsArrayWrite(Opcode opcode)
constexpr Condition Negate(Condition cond)
typedef void(VECTORCALL PWasmOp)(const uint8_t *code
constexpr Register no_reg
constexpr int kTaggedSize
DwVfpRegister DoubleRegister
static constexpr DoubleRegList kEmptyDoubleRegList
Tagged(T object) -> Tagged< T >
RegListBase< Register > RegList
RegListBase< DoubleRegister > DoubleRegList
else if(instr->arch_opcode()==kRiscvCmpZero)
DCHECK(IsNull(value)||IsNativeContext(value)||value==Smi::uninitialized_deserialization_value())
static constexpr RegList kEmptyRegList
kInstanceDescriptorsOffset kTransitionsOrPrototypeInfoOffset prototype
constexpr bool PointerCompressionIsEnabled()
!IsContextMap !IsContextMap native_context
This file provides additional API on top of the default one for making API calls, which come from emb...
#define UNARY_OPERATION_LIST(V)
std::ostream & operator<<(std::ostream &os, const Operation &operation)
#define ARITHMETIC_OPERATION_LIST(V)
#define COMPARISON_OPERATION_LIST(V)
#define DCHECK_LE(v1, v2)
#define DCHECK_NOT_NULL(val)
#define DCHECK_IMPLIES(v1, v2)
#define DCHECK_NE(v1, v2)
#define DCHECK_GE(v1, v2)
#define CHECK_EQ(lhs, rhs)
#define DCHECK(condition)
#define DCHECK_LT(v1, v2)
#define DCHECK_EQ(v1, v2)
#define DCHECK_GT(v1, v2)
constexpr bool IsAligned(T value, U alignment)
const base::Vector< ValueNode * > parameters
compiler::OptionalJSFunctionRef maybe_js_target
const MaglevCompilationUnit & unit
const SourcePosition source_position
const base::Vector< ValueNode * > arguments
const BytecodeOffset bytecode_position
const MaglevCompilationUnit & unit
const BytecodeOffset bytecode_position
const MaglevCompilationUnit & unit
const CompactInterpreterFrameState * frame_state
const SourcePosition source_position
DoubleRegList double_temporaries_
RegListBase< RegisterT > & temporaries()
BasicBlock * owner() const
BasicBlock * operator=(BasicBlock *owner)
RegList live_tagged_registers
DoubleRegList live_double_registers
compiler::FixedDoubleArrayRef values
ValueNode * second() const
std::array< ValueNode *, 2 > data
ValueNode * first() const